﻿namespace SEED.SEEDModels {
    using System;
    using System.Collections.Generic;

    #region Blockette type 005 //Field Volume Identifier Blockette
    /* [005]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  格式版本      |  D    |    4    |     ##.#    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  逻辑记录长度  |  D    |    2    |     ##      |//以2的幂指数表示,12表示4096(2的12次方)
     * +------|----------------|-------|---------|-------------+
     * | 5    |  卷开始时间    |  V    |    1-22 |     TIME    |//卷开始时间一般指敲带末端倾世数据的时间，否则指逻辑卷最早记录时何．可“不考虑长周期数据的记录时同
     * +------|----------------|-------|---------|-------------+
     * 
     */
    /// <summary>
    /// 台站卷标识分区块[005]：本分区块只用于现场台站卷，放在卷首。
    /// </summary>
    public class Block005 : Block {
        #region feild of Block005 class
        private char[] beginOfVolume = new char[22];//1-22B;
        #endregion
        #region Properties of Block005
        public string VersionOfFormat  { get; set; } //Version number of the format, currently “V2.4.”
        public Int16  LogicalRecordLen { get; set; } //Volume logical record length expressed as a power of 2.
        public string BeginTime {
            get {
                string _beginOfVolume = new string(beginOfVolume);
                return _beginOfVolume;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++) {
                    beginOfVolume[i] = str[i];
                }
            }
        }
        #endregion
        #region Constructors of Block005
        public Block005() { }
        public Block005(
            byte[]  blockType,
            Int32   lenOfBlock,
            string   verOfFormat,
            Int16   logicalRecordLen,
            string  _beginOfVolume)
            : base(blockType, lenOfBlock) {
                this.VersionOfFormat    = verOfFormat;
                this.LogicalRecordLen   = logicalRecordLen;
                this.BeginTime          = _beginOfVolume;
        }
        #endregion
    }
    #endregion

    #region Blockette type 008 //Telemetry Volume Identifier Blockette
    /* [008]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  格式版本      |  D    |    4    |     ##.#    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  逻辑记录长度  |  D    |    2    |     ##      |//以2的幂指数表示,12表示4096(2的12次方)
     * +------|----------------|-------|---------|-------------+
     * | 5    |  台站标识符    |  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  位置标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  卷开始时间    |  V    | 1-22    |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  卷结束时间    |  V    | 1-22    |    TIME     |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 遥测卷标识分区块[008]:当用遥测方式传输SEED 数据时,台站卷、台网卷
    /// 和事件卷都可以选用这十分区块,但在V2.4出版时，这个分区块还不曾用过。
    /// </summary>
    public class Block008 : Block005 {
        #region Fields of Block008
        private char[] staIdentifier  = new char[5]; //Station identifier;5-Bytes
        private char[] locIdentifier  = new char[2]; //Location identifier;2-Bytes
        private char[] chaIdentifier  = new char[3]; //Channel identifier;3-Bytes
        private char[] endOfVolume    = new char[22];//End of volume ;1-22 Bytes 
        private char[] staInfoEffDate = new char[22];//Station information effective date ;1-22 Bytes
        private char[] chaInfoEffDate = new char[22];//Channel information effective date;1-22　Bytes
        private char[] networkCode    = new char[2]; //Network Code;2-Bytes
        #endregion

        #region Properties of Block008
        public string StaIdentifier {
            get {
                string _StaIdentifier = new string(staIdentifier);
                return _StaIdentifier;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    staIdentifier[i] = str[i];

                }
            }
        }
        public string LocIdentifier {
            get {
                string _LocIdentifier = new string(locIdentifier);
                return _LocIdentifier;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    locIdentifier[i] = str[i];
                }
            }
        }
        public string ChaIdentifier {
            get {
                string _ChaIdertifier = new string(chaIdentifier);
                return _ChaIdertifier;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    chaIdentifier[i] = str[i];
                }
            }
        }
        public string EndOfVolume {
            get {
                string _EndOfVolume = new string(endOfVolume);
                return _EndOfVolume;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    endOfVolume[i] = str[i];
                }
            }
        }
        public string StaInfoEffDate {
            get {
                string _StaInfoEffDate = new string(staInfoEffDate);
                return _StaInfoEffDate;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    staInfoEffDate[i] = str[i];
                }
            }
        }
        public string ChaInfoEffDate {
            get {
                string _ChaInfoEffData = new string(chaInfoEffDate);
                return _ChaInfoEffData;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    chaInfoEffDate[i] = str[i];
                }
            }
        }
        public string NetworkCode {
            get {
                string _NetwordCode = new string(networkCode);
                return _NetwordCode;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    networkCode[i] = str[i];
                }
            }
        }
        #endregion

        #region Constructors of Block008
        public Block008() { }
        public Block008(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            string  verOfFormat, 
            Int16   locRecordLen,
            string  staIdentifier, 
            string  locIdentifier, 
            string  chaIdentifier, 
            string  begOfVolume,
            string  endOfVolume,
            string  staInfoEffDate,
            string  chaInfoEffDate,
            string  networkCode)
            : base(blockType,lenOfBlock,verOfFormat,locRecordLen,begOfVolume) {
                this.StaIdentifier  = staIdentifier;
                this.LocIdentifier  = locIdentifier;
                this.ChaIdentifier  = chaIdentifier;
                this.EndOfVolume    = endOfVolume;
                this.StaInfoEffDate = staIdentifier;
                this.ChaInfoEffDate = chaInfoEffDate;
                this.NetworkCode    = networkCode;
        }
        #endregion
    }
    #endregion

    #region Blockette type 010 //Volume Identifier Blockette
    /* [010]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  格式版本      |  D    |    4    |     ##.#    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  逻辑记录长度  |  D    |    2    |     ##      |//以2的幂指数表示,12表示4096(2的12次方)
     * +------|----------------|-------|---------|-------------+
     * | 5    |  开始时间      |  V    | 1-22    |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  结束时间      |  V    | 1-22    |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  写卷时间      |  V    | 1-22    |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  创办机构      |  V    | 1-80    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  标识          |  V    | 1-80    |    [UN]     |//这是用来标识该逻辑卷的标记,若不使用标记，本字段必须用一个～表示
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 卷标识分区块[010]：本分区块用于台站卷和事件卷，在每个逻辑卷和逻辑子卷中都将其放在卷首
    /// </summary>
    public class Block010 : Block005 {
        #region Fields of Block010
        private char[] endTime      = new char[22];//1-22 Bytes;The latest time on the logical volume.
        private char[] volumeTime   = new char[22];//1-22 Bytes;The actual date and time that the volume was written.
        private char[] originalOrgz = new char[80];//1-22 Bytes;The organization writing the SEED volume
        private char[] label        = new char[80];//1-22 Bytes;An optional label that can be used to identify this SEED volume
        #endregion

        #region Properties of Block010
        public string EndTime {
            get {
                string _endTime = new string(endTime);
                return _endTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    endTime[i] = str[i];
                }
            }
        }
        public string VolumeTime {
            get {
                string _volumeTime = new string(volumeTime);
                return _volumeTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    volumeTime[i] = str[i];
                }
            }
        }
        public string OriginalOrgz {
            get {
                string oo = new string(originalOrgz);
                return oo;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 80) ? 80 : len;
                for (int i = 0; i < len; i++) {
                    originalOrgz[i] = str[i];
                }
            }
        }
        public string Label {
            get {
                string _label = new string(label);
                return _label;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 80) ? 80 : len;
                for (int i = 0; i < len; i++) {
                    label[i] = str[i];
                }
            }
        }
        #endregion

        #region Constructors of Block010
        public Block010() { }
        public Block010(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            string  verOfFormat, 
            Int16   locRecordLen,
            string  beginTime, 
            string  endTime, 
            string  volumeTime, 
            string  originalOrgz, 
            string  label)
            : base(blockType, lenOfBlock, verOfFormat, locRecordLen, beginTime) {
                this.EndTime      = endTime;    
                this.VolumeTime   = volumeTime;  
                this.OriginalOrgz = originalOrgz;
                this.Label        = label;       
        }
        #endregion
    }
    #endregion

    #region Blockette type 011 //Volume Station Header Index Blockette
    /* [011]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  台站数目      |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  台站标识符    |  A    |    5    |     [UN]    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |所在逻辑记录序号|  D    |    6    |   ######    |//对于字段4培出的每一个台站，都有唯一的台站标识分区块[050]与其对应。本字段对各台站的[050]进行索引，指出它们在本卷中所在逻辑记录的顺序号
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 卷台站头段索引分区块[011]:本分区块对台站标识分区块[050]进行索引，台站卷不使用这个分区块。
    /// </summary>
    public class Block011 : Block {
        #region Fields of Block011
        private List<char[]> staIDCode    = new List<char[]>();//台站标识符列表，其每个标识符不能大于5个字节
        private byte[] numOfStations      = new byte[3];       //3-Bytes;The number of stations that will be represented later by Station identifier Blockettes [50] in the station header
                                                               //section. The next two fields each repeat, once per station, for the total number of stations.
        private List<byte[]> seqNumOfStaH = new List<byte[]>();//台站头段所在逻辑记录的顺序号列表，其每一个序号不能大于6字节
        #endregion

        #region Properties of Block011
        //以下只读私有属性只在本类中使用
        private int Count {
            get {
                if (BitConverter.IsLittleEndian)
                    Array.Reverse(this.numOfStations);
                return BitConverter.ToInt32(this.numOfStations, 0);
            }
        }
        public byte[] NumOfStations {
            get {
                return this.numOfStations;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.NumOfStations[i] = value[i];
                }
            }
        }
        public List<byte[]> SeqNumOfStaH {
            get {
                return this.seqNumOfStaH;
            }
            set {
                //根据台站数目设置每个台站的所在逻辑记录中的顺序号
                for (int i = 0; i < Count; i++) {
                    //对其中的各顺序号进行设置，其长度不能大于6字段
                    byte[] stationIDCode = new byte[6];
                    int len = value[i].Length;
                    len = (len > 6) ? 6 : len;
                    for (int j = 0; j < len; i++) {
                        stationIDCode[i] = value[i][j];
                    }
                    this.seqNumOfStaH.Add(stationIDCode);
                }

            }
        }
        public List<char[]> StationIDCode {
            get {
                return this.staIDCode;
            }
            set {
                for (int i = 0; i < Count; i++) {
                    //对其中的各种台站标识符进行设置，其长度不能大于5字段
                    char[] stationIDCode = new char[5];
                    int len = value[i].Length;
                    len = (len > 5) ? 5 : len;
                    for (int j = 0; j < len; i++) {
                        stationIDCode[i] = value[i][j];
                    }
                    this.staIDCode.Add(stationIDCode);
               }
            }
        }
        #endregion

        #region Constuctors of Block011
        public Block011() { }
        public Block011(
            byte[]  blockType, 
            Int32   lenOfBlock,
            byte[]  numOfSta, 
            List<char[]> staIDCode, 
            List<byte[]> seqNumOfStaH)
            : base(blockType, lenOfBlock) {
                this.StationIDCode = staIDCode;
                this.NumOfStations = numOfSta;
                this.SeqNumOfStaH  = seqNumOfStaH;
        }
        #endregion
    }
    #endregion

    #region Blockette type 012 //Volume Time Span Index Blockette
    /* [012]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  时间片个数    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    | 时间片开始时间 |  V    | 1-22    |    TIME     |//与时间片标识分区块[070]列出的开始时间相同
     * +------|----------------|-------|---------|-------------+
     * | 5    | 时间片结束时间 |  V    | 1-22    |    TIME     |//与时间片标识分区块[070]列出的结束时间相同
     * +------|----------------|-------|---------|-------------+
     * | 6    | 时间片所在逻号 |  D    |    6    |    ######   |//指该时间片标识分区块[070]所在的逻辑记录的顺序号
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 卷时间片索引分区块[012]：这个分区块对该卷中的时间片进行索引，
    /// 每一个时间片控制头段都有一个索引入口，台站卷不使用这个分区块
    /// </summary>
    public class Block012 : Block {
        #region Fields of Block012
        private List<char[]> beginOfTSpan   = new List<char[]>();//1-22 Bytes;The beginning time of the time span. This should be the same time 
                                                                 //as is in the Time Span Identifier Blockette [70] to which it refers.
        private List<char[]> endOfTSpan     = new List<char[]>();//1-22 Bytes;The time span ending time.
        private List<byte[]> seqNumOfTSpH   = new List<byte[]>();//6-Bytes;The sequence number of the record on which the Time Span Identifier Blockette [70] referred to starts.
        #endregion

        #region Properties of Block012
        public Int32 NumOfTSpanInTable { get; set; } //4-Bytes;The number of time spans present in this blockette. 
                                                    //The next three fields each repeat, once per time span, for the total number of time spans.
        public List<byte[]> SeqNumOfTSpanH {
            get {
                return this.seqNumOfTSpH;
            }
            set {
                for (int index = 0; index < NumOfTSpanInTable; index++) {
                    byte[] seqNum = new byte[6];
                    int len = value[index].Length;
                    len = (len > 6) ? 6 : len;
                    for (int i = 0; i < len; i++) {
                        seqNum[i] = value[index][i];
                    }
                    this.seqNumOfTSpH.Add(seqNum);
                }
            }
        }
        public List<char[]> BeginOfTSpan {
            get {
                return beginOfTSpan;
            }
            set {
                for (int index = 0; index < NumOfTSpanInTable; index++) {
                    char[] beginTime = new char[22];
                    int len = value[index].Length;
                    len = (len > 22) ? 22 : len;
                    for (int i = 0; i < len; i++) {
                        beginTime[i] = value[index][i];
                    }
                    this.beginOfTSpan.Add(beginTime);
                }
            }
        }
        public List<char[]> EndOfTSpan {
            get {
                return endOfTSpan;
            }
            set {
                for (int index = 0; index < NumOfTSpanInTable; index++) {
                    char[] endTime = new char[22];
                    int len = value[index].Length;
                    len = (len > 22) ? 22 : len;
                    for (int i = 0; i < len; i++) {
                        endTime[i] = value[index][i];
                    }
                    this.EndOfTSpan.Add(endTime);
                }
            }
        }
        #endregion

        #region Constructors of Volume Time Span Index Blockette
        public Block012() { }
        public Block012(
            byte[]  blockType, 
            Int32   lenOfBlock,
            Int32   numOfTSpanInTable,
            List<char[]>  beginOfSpan, 
            List<char[]>  endOfSpan, 
            List<byte[]>  seqNumOfTSpanH)
            : base(blockType, lenOfBlock) {
                this.NumOfTSpanInTable = numOfTSpanInTable;
                this.BeginOfTSpan      = beginOfSpan;
                this.EndOfTSpan        = endOfSpan;
                this.SeqNumOfTSpanH    = seqNumOfTSpanH;
        }
        #endregion
    }
    #endregion

    #region Blockette type 030 //Data Format Dictionary Blockette
    /* [030]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  数据格式简名  |  V    | 1-50    |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     * | 4    |数据格式标识代码|  D    |    4    |    ####     |//这是一个相互引用代码(字典入口)，它只在本卷有意义．卷内第一次出现的数据格式标识代码指定为1；以后逐次加1．通道标识分区块[052]字段l6引用这个代码。
     * +------|----------------|-------|---------|-------------+
     * | 5    | 数据簇类型     |  D    |    3    |    ###      |//数据族类型有五种 (0 整璺固定间隔数据 (l 增益调整固定间隔数据 (5O 整型差分缩敦据 (80 行控ASCII文本 (8l 非ASCII文本
     * +------|----------------|-------|---------|-------------+
     * | 6    | 解码关键字个数 |  D    |    2    |    ##       |//每种数据族都有几个解码关键字．详见原文附录D
     * +-------------------------------------------------------+
     * | 7    | 解码关键字     |  V    |  任意   |    [UNLPS]  |//解码关键字须按照原文附录D的规定编写，每个解码关键字之后用～结束
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 数据格式字典分区块[030]:这是各种逻辑卷都使用的分区块，
    /// 每一种数据格式都有一个格式代码(字典入口)，据此，SEED读程序可对数据进行解码。
    /// </summary>
    public class Block030 : Block {
        #region Fields of Block030
        private char[] _ShortDesName     = new char[50];//1-50B;A short name describing the data type. See Appendix D.
        private byte[] _DataFamilyType   = new byte[3]; //3B;A field used by the data decoder to describe the data family type.
        private List<string> decoderKeys = new List<string>();
        #endregion

        #region Properties of Block030
        public Int32    DataFormatIdentCode  { get; set; }//4B;A cross reference number, used in later blockettes, to indicate this particular dictionary entry.
        public Int16    NumOfDecodKeys      { get; set; }//2B;The number of decoder keys used by the data family type (see Appendix D).
        public List<string> DecoderKeys {
            get {
                return this.decoderKeys;
            }
            set {
                for (int i = 0; i < NumOfDecodKeys; i++) {
                    this.decoderKeys.Add(value[i]);
                }
            }
        }
        public byte[] DataFamilyType {
            get {
                return this._DataFamilyType;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this._DataFamilyType[i] = value[i];
                }
            }
        }
        public string ShortDesName {
            get {
                string shortDesName = new string(_ShortDesName);
                return shortDesName;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 50) ? 50 : len;
                for (int i = 0; i < len; i++) {
                    this._ShortDesName[i] = str[i];
                }
            }
        }
        #endregion

        #region Constuctors of Block030
        public Block030(){}
        public Block030(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            string  shortDesName,
            Int32   dataFormatIdenCode,
            byte[]  dataFamilyType, 
            Int16   numOfDesKeys, 
            List<string>  decoderKeys)
            : base(blockType, lenOfBlock) {
                this.ShortDesName       = shortDesName;
                this.DataFormatIdentCode = dataFormatIdenCode;
                this.DataFamilyType     = dataFamilyType;
                this.NumOfDecodKeys     = numOfDesKeys;
                this.DecoderKeys        = decoderKeys;
        }
        #endregion
    }
    #endregion

    #region Blockette type 031 //评论描述块
    /* [031]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  注释代码      |  D    |    4    |    ####     |//此代码由用户设定，是一个相互引用代码，对于每一个注释．它是唯一的。台站注释分区堍[051]的字段 5和通道注释分区抉[039]的字段5引用这个代码.原文附录E给出的实倒,建议将这些注释代码标准化
     * +------|----------------|-------|---------|-------------+
     * | 4    |  注释代码分类  |  A    |    1    |    [U]      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  注释描述      |  V    |  1-70   |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     * | 6    | 注注释物理单位 |  D    |    3    |    ###      |//如果注释描述的是物理量。该字段是表示物理量单位的代码。引自单位简写分区抉[O34]的字段3,否则该字段为零。
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 注释描述分区块[031]:本分区块为工作人员、收集中心和
    /// 管理中心提供一些注释信息,用来描述所遇到的问题和特殊情况。
    /// </summary>
    public class Block031:Block{
        #region  评论描述块——字段部分
        private char[] desOfComment         = new char[70];//Description of comment:1-70 bytes
        private byte[] unitsOfComtLevel     = new byte[3]; //3B;If a value is associated with the comment, place the unit lookup code from field 3 of 
        #endregion
        #region 评论描述块——属性部分
        public Int32  ComtCodeKey       { get; set; }//Comment code key:4 bytes                           
        public char   ComtClassCode     { get; set; }//Comment class code:1 byte 
        public byte[] UnitsOfComtLevel {
            get {
                return unitsOfComtLevel;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.unitsOfComtLevel[i] = value[i];
                }
            }
        }
        public string DescriptionComt { //评论描述 
            get{
                string _desciptionComment = new string(desOfComment);
                return _desciptionComment;
            }
            set
            {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (Len > 70) ? 70 : Len;
                for (int i = 0; i < Len; i++)
                    desOfComment[i] = str[i];
            }
        }
        #endregion
        #region Constuctors of [31]评论描述块
        public Block031(){}
        public Block031(
            byte[]  blockType,
            Int32   lenOfBlock,
            Int32   comtCodeKey, 
            char    comtClassCode, 
            string  desOfComt, 
            byte[]  unitsOfComtLevel)
            : base(blockType, lenOfBlock) {
                this.ComtCodeKey        = ComtCodeKey;
                this.ComtClassCode      = comtClassCode;
                this.DescriptionComt    = desOfComt;
                this.UnitsOfComtLevel   = unitsOfComtLevel;
        }
        #endregion
    }
    #endregion

    #region Blockette type 032 //被引用的源字典块--类设计
    /* [032]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  出处查询代码  |  D    |    2    |    ##       |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  刊物/作者名   |  V    |  1-70   |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  出版编目日期  |  V    |  1-70   |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  发行人姓名    |  V    |  1-50   |    [UNLPS]  |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 引用源字典分区块[032]:本分区块提供震源和震级信息的来源(出处)，一般用于事件卷。
    /// </summary>
    public class Block032:Block {
        #region 被引用的源字典块--字段部分     
        private Char[] nameOfPublication    = new Char[70];//1-70B;Name of publication/author     
        private Char[] datePublished        = new Char[70];//1-70B;Date published/catalog      
        private Char[] publisherName        = new Char[50];//1-50B;Publisher name     
        #endregion

        #region 被引用的源字典块--属性部分
        public Int16 SourceLookupCode   { get; set; }//Source lookup code:2 bytes
        public string NameOfPublication {
            get{
                string _nameOfPublication = new string(nameOfPublication);
                return _nameOfPublication;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (70 < Len) ? 70 : Len;
                for (int i = 0; i < Len; i++)
                    nameOfPublication[i] = str[i];
            }
        }
        public String DatePublished {
            get{
                string _datePublished = new string(datePublished);
                return _datePublished;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (70 < Len) ? 70 : Len;
                for (int i = 0; i < Len; i++)
                    datePublished[i] = str[i];
            }
        }
        public String PublisherName {
            get{
                string _publisherName = new string(publisherName);
                return _publisherName;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (50 < Len) ? 50 : Len;
                for (int i = 0; i < Len; i++)
                    publisherName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of [32]被引用的源字典块
        public Block032() { }
        public Block032(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            string  _nameOfPublication,
            string  _dataPublished, 
            string  _publisherName, 
            Int16   _sourceLookupCode)
            : base(blockType, lenOfBlock) {
                this.NameOfPublication  = _nameOfPublication;
                this.DatePublished      = _dataPublished;
                this.PublisherName      = _publisherName;
                this.SourceLookupCode   = _sourceLookupCode;
        }
        #endregion
    }
    #endregion

    #region Blockette type 033 //抽象缩写块---类设计
    /* [033]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  简写查询代码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  简写文本      |  V    |  1-50   |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 一般简写分区块[033]:本分区抉对台站仪器或通道、台网及其归属给于简单描述．
    /// </summary>
    public class Block033 : Block {
        #region Generic Abbreviation Blockette---fields                       
        private char[] abbDescription   = new char[50];//Abbreviation description:1-50 bytes
        private byte[] abbLookupCode    = new byte[3]; //Abbreviation lookup code:3 bytes
        #endregion

        #region Generic Abbreviation Blockette---properties
        public byte[] AbbLookupCode{
            get {
                return this.abbLookupCode;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.abbLookupCode[i] = value[i];
                }
            }
        }
        public string AbbDescription {
            get{
                string _abbreviationDescription = new string(abbDescription);
                return _abbreviationDescription;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (50 < Len) ? 50 : Len;
                for (int i = 0; i < Len; i++)
                    abbDescription[i] = str[i];
            }
        }
        #endregion

        #region Constructors of [33]抽象缩写块
        public Block033() { }
        public Block033(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            byte[]  _abbLookupCode, 
            string  _abbDescription)
            : base(blockType, lenOfBlock) {
                this.AbbLookupCode  = _abbLookupCode;
                this.AbbDescription = _abbDescription;
        }
        #endregion
    }
    #endregion

    #region Blockette type 034 //单元缩写块--类设计
    /* [034]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  单位查询代码  |  D    |    3    |    ###      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  单位名称      |  V    |  1-20   |    [UNLPS]  |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  单位描述      |  V    |  0-50   |    [UNLPS]  |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 单位简写分区块[034]:本分区块给出物理量的单位和代码。
    /// </summary>
    public class Block034 : Block {
        #region Units Abbreviations Blockette---fields                  
        private Char[] unitName         = new Char[20]; //1-20B;
        private Char[] unitDescription  = new Char[50]; //1-50B;
        private byte[] unitLookupCode   = new byte[3];  //3B;
        #endregion

        #region Units Abbreviations Blockette---properties
        public byte[] UnitLookupCode {
            get {
                return this.unitLookupCode;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.unitLookupCode[i] = value[i];
                }
            }
        }
        public String UnitName {
            get{
                string _unitName = new string(unitName);
                return _unitName;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (20 < Len) ? 20 : Len;
                for (int i = 0; i < Len; i++)
                    unitName[i] = str[i];   
            }
        }
        public String UnitDescription {
            get{
                string _unitDescription = new string(unitDescription);
                return _unitDescription;
            }
            set{
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (50 < Len) ? 50 : Len;
                for (int i = 0; i < Len; i++)
                    unitDescription[i] = str[i];
            }
        }
        #endregion

        #region Constuctors of [34] 单元缩写块
        public Block034() { }
        public Block034(
            byte[]  blockType, 
            Int32   lenOfBlock,
            byte[]  _unitLookupCode, 
            string  _unitName, 
            string  _unitDescription)
            : base(blockType, lenOfBlock) {
                this.UnitName           = _unitName;
                this.UnitDescription    = _unitDescription;
                this.UnitLookupCode     = _unitLookupCode;
        }
        #endregion
    }
    #endregion

    #region Blockette type 035 //电波配置块(Beam Configuration Blockette)--类设计
    /* [035]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |//当车分区块长度超过9999字节或99十台站时，继续写一个[035]，二个分区块使用相同的B m代码．
     * +------|----------------|-------|---------|-------------+
     * | 3    |  Beam查询代码  |  D    |    3    |     ###     |//这是一个相互引用代码(字典入13)，Beam分区块[400]的宇段5引用这个代码．它只在本卷有意义，在卷内第一次出现的Beam查询代码指定为1,以后逐次加1．
     * +------|----------------|-------|---------|-------------+
     * | 4    |  分量成员数目  |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  台站标识符    |  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  位置标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  子通道标识符  |  D    |    4    |    ####     |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  分量成员权重  |  D    |    5    |    #####    |//在Beam计算时给于该成员的加权．
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// Beam结构分区块[035]:车分区块用一种Beam形成算法合成输出来描述一个仪器阵列的构成情况，
    /// 数据头段的Beam分区块[400]引用这个字典．它是简写字典控制头丧中唯一被用到数据记录头段中的分区块．
    /// </summary>
    public class Block035 : RptIndentBlock {
        #region 电波配置块--字段部分 
        private byte[] beamLookupCode   = new byte[3];//3B;Beam lookup code
        private byte[] comptWeight      = new byte[5];//5B;Component weight
        private List<int>    subChaIdent   = new List<int>();
        #endregion

        #region 电波配置块--属性部分
        public Int32 NumOfCompts { get; set; }//Number of components:4B
        public List<Int32> SubChaIdent {
            get {
                return this.subChaIdent;
            }
            set{
                for (int i = 0; i < NumOfCompts; i++) {
                    this.subChaIdent.Add(value[i]);
                }
            }
        }
        public byte[] BenmLookupCode {
            get {
                return this.beamLookupCode;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.beamLookupCode[i] = value[i];
                }
            }
        }
        public byte[] ComptWeight {
            get {
                return this.comptWeight;
            }
            set {
                int len = value.Length;
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    this.comptWeight[i] = value[i];
                }
            }
        }
        #endregion

        #region Constructors os of [35]电波配置块(Beam Configuration Blockette)
        public Block035() { }
        public Block035(
            byte[] blockType,
            Int32 lenOfBlock,
            byte[] _beamLookupCode,
            Int32 numOfCompt,
            List<char[]> staInden,
            List<char[]> locatIden,
            List<char[]> chaInden,
            List<int>    subChaIdent,
            byte[] _comptWeight)
            : base(blockType, lenOfBlock, numOfCompt, staInden, locatIden, chaInden) {
                this.BenmLookupCode = _beamLookupCode;
                this.NumOfCompts = numOfCompt;
                this.SubChaIdent = subChaIdent;
                this.ComptWeight = _comptWeight;
        }
        #endregion
    }
    #endregion

    #region Blockette type 041 //FIR Dictionary Blockette--类设计
    /* [041]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    | 响应查询关键字 |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN]    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  对称性代码    |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  输入信号单位  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  输出信号单位  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  因子个数      |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  FIR系数       |  F    |    14   |-#.######E-##|
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// FIR字典分区块[041]:FIR字典分区块用来说明有限脉冲响应(FIR)数字滤波器的系数。 
    /// 在说明FIR滤被器时，这个分区块可以代替响应系数字典分区块[044]。
    /// 本分区块能区分滤波器对称性的不同类型，并利用其缩减所要说明的因数数目。
    /// 本分区块与FIR响应分区块[061]对应。
    /// </summary>
    public class Block041 : FIR {
        #region FIR Dictionary Blockette---properties
        public Int32 RespLookupKey { get; set; }
        #endregion

        #region Constructors of [41]FIR Dictionary Blockette--类设计
        public Block041() { }
        public Block041(byte[] blockType, Int32 lenOfBlock, Int32 respLookupKey, char[] _respName, 
            Char symmetryCode, byte[] _signalInUnits, byte[] _signalOutUnits,Int32 numOfFactors, List<byte[]> _FIRCoefficient)
            : base(blockType, lenOfBlock, _respName, _signalInUnits, _signalOutUnits, symmetryCode, numOfFactors, _FIRCoefficient) {
                this.RespLookupKey = respLookupKey;
        }
        #endregion
    }
    #endregion

    #region Blockette type 042/049[So Named it Block042N049] //Response(Polynomial)Dictionary Blockette--类设计
    /* [042]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询代码  |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  传递函数类型  |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  多项式逼近类型|  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  有效频率单位  |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  有效频率下界  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  有效频率上界  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  逼近下界      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 13   |  逼近上界      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  最大绝对误差  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  多项式系数个数|  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  多项式系数    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 17   |  多项式系数误差|  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+ 
     */
    /// <summary>
    /// 响应(多项式)字典块[042]:使用此小块来刻画一个非线性的传感器响应。
    /// </summary>
    public class Block042N049 : Polynomial {
        #region Response(Polynomial)Dictionary Blockette--字段部分
        private Char[] respName = new Char[25]; //Response Name:1-25B
        #endregion

        #region Response(Polynomial)Dictionary Blockette--属性部分
        public Int32 RespLookupKey { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of [42]Response(Polynomial)Dictionary Blockette
        public Block042N049() { }
        public Block042N049(
            byte[]  blockType,
            Int32   lenOfBlock, 
            Int32   respLookupKey,
            string  _respName,
            char    transFuncType, 
            byte[]  _stageSignalInutUnits,
            byte[]  _stageSignalOutputUnites, 
            char    polyApproxType, 
            char    validFreqUnits, 
            float[] _lowerValidFreqBound, 
            float[] _upperValidFreqBound,
            float[] _lowerBoundOfApprox, 
            float[] _upperBoundOfApprox, 
            float[] _maxAbsoluteError, 
            byte[]  _numOfPolyCoeffi, 
            List<float[]> _polyCoeffi, 
            List<float[]> _polyCoeffiError
            )
            : base(blockType,lenOfBlock, transFuncType, _stageSignalInutUnits,_stageSignalOutputUnites,
            polyApproxType, validFreqUnits, _lowerValidFreqBound, _upperValidFreqBound,_lowerBoundOfApprox, 
            _upperBoundOfApprox, _maxAbsoluteError, _numOfPolyCoeffi, _polyCoeffi, _polyCoeffiError) {
                this.RespLookupKey  = respLookupKey;
                this.RespName       = _respName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 043 //Response(Poles & Zeros)Dictionary Blokette--类设计
    /* [043]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  响应类型      |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  AO归一因子    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  归一化频率    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  复零点个数    |  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  实零点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  虚零点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 13   |  实零点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  虚零点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  复极点个数    |  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  实极点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 17   |  虚极点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 18   |  实极点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 19   |  虚极点误差    |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    ///<summary>
    /// 响应(极点／零点)字典分区块[043]
    /// </summary>
    public class Block043 : PolesNZeros {
        #region Response(Poles & Zeros)Dictionary Blokette--字段部分
        private Char[] respName     = new Char[25]; //Response Name:1-25B 
        #endregion

        #region Response(Poles & Zeros)Dictionary Blokette--属性部分
        public char  RespType       { get; set; }
        public Int32 RespLookupKey  { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of Response(Poles & Zeros)Dictionary Blokette
        public Block043() { }
        public Block043(byte[] blockType, Int32 lenOfBlock, Int32 respLookupKey, string _respName, char respType,
            byte[] stageSignalInputUnits, byte[] stageSignalOutputUnits,float[] aONormalizationFactor, 
            float[] normalizationFreq, byte[] numOfComplexZeros, List<float[]> realZero, List<float[]> imaginaryZero,
            List<float[]> realZeroError, List<float[]> imaginaryZeroError,byte[] numOfCompexPoles,
            List<float[]> realPole, List<float[]> imaginaryPole, List<float[]> realPoleError,List<float[]> imaginaryPoleError)
            : base(blockType, lenOfBlock, stageSignalInputUnits, stageSignalOutputUnits,aONormalizationFactor, 
            normalizationFreq, numOfComplexZeros,realZero, imaginaryZero, realZeroError, imaginaryZeroError,
            numOfCompexPoles, realPole, imaginaryPole, realPoleError, imaginaryPoleError) {
                this.RespType       = respType;
                this.RespName       = _respName;
                this.RespLookupKey  = respLookupKey;
        }
        #endregion
        }
    #endregion

    #region Blockette type 044 //Response(coefficients)Dictionary Blockette--类设计
    /* [044]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  响应类型      |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  分子个数      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  分子系数      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  分子系数误差  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  分母个数      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  分母系数      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 13   |  分母系数误差  |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 响应(系数)字典分区块[044]
    /// </summary>
    public class Block044 : Coefficients {
        #region Response(coefficients)Dictionary Blockette--字段部分
        private Char[] respName = new Char[25]; //Response Name:1-25B 
        #endregion

        #region Response(coefficients)Dictionary Blockette--属性部分
        public char  RespType       { get; set; }
        public Int32 RespLookupKey  { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of Response(coefficients)Dictionary Blockette
        public Block044() { }
        public Block044(byte[] blockType, Int32 lenOfBlock, byte[] signalInpuUnits, 
            byte[] signalOutputUnits, Int32 numOfNumerators, List<float[]> numeratorCoeffi, 
            List<float[]> numeratorError,Int32   numOfDenominators, List<float[]> denominatorCoeffi, 
            List<float[]> denominatorError,Int32 respLookupKey, string _respName, char respType)
            : base(blockType, lenOfBlock, signalInpuUnits, signalOutputUnits, numeratorCoeffi,
            numeratorError,denominatorCoeffi,denominatorError,numOfNumerators,numOfDenominators) {
                this.RespType       = respType;
                this.RespName       = _respName;
                this.RespLookupKey  = respLookupKey;
        }
        #endregion
    }
    #endregion

    #region Blockette type 045 //Response List Dictionary Blockette--类设计
    /* [045]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  列出的响应项目|  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  响应频率(Hz)  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  响应振幅      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  振幅误差      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  相位角(度)    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 12   |  相位角误差    |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// -响应目录字典分区块[045]
    /// </summary>
    public class Block045 : _List {
        #region Response List Dictionary Blockette--字段部分
        private Char[] respName = new Char[25]; //Response Name:1-25B 
        #endregion

        #region Response List Dictionary Blockette--属性部分
        public Int32 RespLookupKey { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Contructors of Response List Dictionary Blockette
        public Block045() { }
        public Block045(
            byte[]  blockType,
            Int32   lenOfBlock,
            Int32   respLookupKey,
            string  _respName,
            byte[]  signalInputUnits,
            byte[]  signalOutputUnits,
            Int32   numOfRespListed,
            List<float[]> frequency,
            List<float[]> amplitude,
            List<float[]> amplitudeError,
            List<float[]> phaseAngle,
            List<float[]> phaseError
            )
            : base(blockType, lenOfBlock, signalInputUnits, signalOutputUnits,frequency,
            amplitude,amplitudeError,phaseAngle,phaseAngle,numOfRespListed) {
                this.RespLookupKey   = respLookupKey;
                this.RespName        = _respName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 046 //Generic Response Dictionary Blockette--类设计
    /* [046]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  半功率点个数  |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  半功率点频率  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  半功率点斜率  |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 一般响应字典分区块[046]
    /// </summary>
    public class Block046 : _Generic {

        #region Fields of [46]Generic Response Dictionary Blockette
        private Char[] respName = new Char[25]; //Response Name:1-25B 
        #endregion

        #region Generic Response Dictionary Blockette--属性部分
        public Int32 RespLookupKey { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of [46]Generic Response Dictionary Blockette
        public Block046() { }
        public Block046(
            byte[] blockType,
            Int32 lenOfBlock,
            Int32 respLookupKey,
            string _respName,
            byte[] signalInputUnits,
            byte[] signalOutputUnits,
            Int32 numOfCornersListed,
            List<float[]> cornerFreq,
            List<float[]> cornerSlope
            )
            : base(blockType, lenOfBlock, signalInputUnits, 
            signalOutputUnits,numOfCornersListed,cornerFreq,cornerSlope) {
                this.RespLookupKey   = respLookupKey;
                this.RespName        = _respName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 047 //Decimation Dictionary Blockette--类设计
    /* [047]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  输入采样率    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  数据抽取因子  |  D    |    5    |   #####     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  抽取偏置      |  D    |    5    |   #####     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  估计延时(秒)  |  F    |    11   |-#.####E-##  |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  实际校正(秒)  |  F    |    11   |-#.####E-##  |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 数据抽取字典分区块[047]
    /// </summary>
    public class Block047 : Decimation{
        #region Decimation Dictionary Blockette--字段部分
        private Char[] respName = new Char[25]; //Response Name:1-25B 
        #endregion

        #region Decimation Dictionary Blockette--属性部分
        public Int32 RespLookupKey { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion 

        #region Constructors of [47]Decimation Dictionary Blockette
        public Block047() { }
        public Block047(
            byte[]  blockType,
            Int32   lenOfBlock,
            Int32   respLookupKey,
            string  _respName,
            byte[]  _inputSampleRate,
            byte[]  _decimationFactor,
            byte[]  _decimationOffset,
            byte[]  _estimatedDelay,
            byte[]  _correctionApplied
            )
            : base(blockType, lenOfBlock,_inputSampleRate,_decimationFactor,
            _decimationOffset,_estimatedDelay,_correctionApplied) {
                this.RespLookupKey  = respLookupKey;
                this.RespName       = _respName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 048 //Channel Sensitivity/Gain Dictionary Blockette--类设计
    /* [048]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应查询关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  灵敏度/增益   |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  频率(HZ)      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  历次标定的数目|  D    |    2    |   ##        |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  灵敏度标定    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  标定频率      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  标定时间      |  V    |    1-22 |     TIME    |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 通道灵敏度/增益字典分区块[048]
    /// </summary>
    public class Block048 : SensitivityNGain {
        #region Channel Sensitivity/Gain Dictionary Blockette--字段部分
        private Char[] respName = new Char[25]; //Response Name:1-25B
        #endregion

        #region Channel Sensitivity/Gain Dictionary Blockette--属性部分
        public Int32 RespLookupKey { get; set; }//Response Lookup Key：4B
        public string RespName {
            get {
                string _responseName = new string(respName);
                return _responseName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (25 < Len) ? 25 : Len;
                for (int i = 0; i < Len; i++)
                    respName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of [48]Channel Sensitivity/Gain Dictionary Blockette
        public Block048() { }
        public Block048(
            byte[]  blockType,
            Int32   lenOfBlock,
            List<char[]>  _timeOfAboveCalibration,
            float[] _sensitivityNGain,      
            float[] _frequency,             
            List<float[]> _sensitForCalibration,  
            List<float[]> _freqOfCalibrationSens,
            string  _respName,
            Int32   _respLookupKey
            )
            : base(blockType,lenOfBlock,_timeOfAboveCalibration,
            _sensitivityNGain,_frequency,_sensitForCalibration,_freqOfCalibrationSens) {
                this.RespName       = _respName;
                this.RespLookupKey  = _respLookupKey;
        }
        #endregion
    }
    #endregion

    #region Blockette type 050 ////Station Identifier Blockette
    /* [050]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  台站标识符    |  A    |    5    |     [UN]    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  纬度(度)      |  D    |    10   |-##.######   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  经度(度)      |  D    |    11   |-###.######  |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  海拔(米)      |  D    |    7    |-####.#      |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  通道数        |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 8    |台站注释分区块数|  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  台站行政名称  |  V    |    1-60 |  [UNLPS]    |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  台站标识代码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  长字(32位)命令|  D    |    4    |   ####      | 
     * +------|----------------|-------|---------|-------------+
     * | 12   |  字(16位)命令  |  D    |    2    |    ##       |
     * +------|----------------|-------|---------|-------------+
     * | 13   |  有效开始日期  |  V    |  1-22   |   TIME      |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  有效结束日期  |  V    |  0-22   |   TIME      |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  修改标志      |  A    |  1      |             |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  台网代码      |  A    |  2      |   [UN]      |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 台站标识分区块[050]
    /// 若本分区块在卷的时间间隔内有变化，应在第一个[050]之后紧跟着写一个新的分区块[050]
    /// </summary>
    public class Block050 : For050N052 {
        #region fields of Block050
        private char[] staCallLetters   = new char[5];  //5B;
        private byte[] numOfStaCommt    = new byte[3];  //3B;D-Type;
        private char[] siteName         = new char[60]; //1-60B;
        private byte[] networkIdenCode  = new byte[3];  //3B;D-Type;
        private char[] networkCode      = new char[2];  //2B;A-Type;
        #endregion

        #region Properties of Block050
        public Int32 NumOfChannels  { get; set; }
        public Int32 _32bWordOrder  { get; set; }
        public Int16 _16bWordOrder  { get; set; }
        public string StaCallLetters {
            get {
                string _staCallLetters = new string(staCallLetters);
                return _staCallLetters;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    staCallLetters[i] = str[i];
                }
            }
        }
        public byte[] NumOfStaCommt {
            get {
                return this.numOfStaCommt;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.numOfStaCommt[i] = value[i];
                }
            }
        }
        public string SiteName {
            get {
                string _siteName = new string(siteName);
                return _siteName;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 60) ? 60 : len;
                for (int i = 0; i < len; i++) {
                    siteName[i] = str[i];
                }
            }
        }
        public byte[] NetworkidenCode {
            get {
                return this.networkIdenCode;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.networkIdenCode[i] = value[i];
                }
            }
        }
        public string NetworkCode{
            get {
                string _networkCode = new string(networkCode);
                return _networkCode;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    networkCode[i] = str[i];
                }
            }
        }
        #endregion

        #region constructors of Block050
        public Block050() { }
        public Block050(
            byte[]  blockType,
            Int32   lenOfBlock,
            byte[]  _latitude,
            byte[]  _longitude,
            byte[]  _elevation,
            string  _startDate,
            string  _endDate,
            char    updateFlag,
            string  _staCallLetters,
            byte[]  _numOfStaCommt,
            string  _siteName,
            byte[]  _networkIdenCode,
            string  _networkCode,
            Int32   numOfChannels,
            Int32   _32bOrder,
            Int16   _16bOrder
            )
            : base(blockType, lenOfBlock, _latitude, _longitude, _elevation, _startDate, _endDate, updateFlag) {
                this.StaCallLetters     = _staCallLetters;
                this.NumOfStaCommt      = _numOfStaCommt;
                this.SiteName           = _siteName;
                this.networkIdenCode    = _networkIdenCode;
                this.NetworkCode        = _networkCode;
                this.NumOfChannels      = numOfChannels;
                this._32bWordOrder      = _32bOrder;
                this._16bWordOrder      = _16bOrder;
        }
        #endregion
    }
    #endregion

    #region Blockette type 051/059[So Named it Block051N059] //Station or Channel Comment Blockette
    /* [051]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  有效开时间    |  V    |    1-22 |     TIME    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  有效结束时间  |  V    |    1-22 |     TIME    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  注释代码关键字|  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 6    |注释层(物理单位)|  D    |    6    |   ######    |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 台站注释分区块[051]
    /// </summary>
    public class Block051N059 : Block {
        #region fields of Block051N059
        private char[] beginEffTime = new char[22];// 1-22 Bytes;The time when the comment comes into effect.
        private char[] endEffTime   = new char[22];// 1-22 Bytes;The time when the comment is no longer in effect.
        private byte[] commtLevel   = new byte[6]; //6B;D-Type;
        #endregion

        #region properties of Block051N059
        public Int32 CommtCodeKey { get; set; }
        public string BeginEffectTime {
            get {
                string _beginEffTime = new string(beginEffTime);
                return _beginEffTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    beginEffTime[i] = str[i];
                }
            }
        }
        public string EndEffectTime {
            get {
                string _endEffTime = new string(endEffTime);
                return _endEffTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    endEffTime[i] = str[i];
                }
            }
        }
        public byte[] CommtLevel {
            get {
                return this.commtLevel;
            }
            set {
                int len = value.Length;
                len = (len > 6) ? 6 : len;
                for (int i = 0; i < len; i++) {
                    commtLevel[i] = value[i];
                }
            }
        }
        #endregion

        #region constructors of Block051N059
        public Block051N059() { }
        public Block051N059(
            byte[] blockType,
            Int32  lenOfBlock,
            string _beginEffTime,
            string _endEffTime,
            byte[] commtLevel,
            Int32  commtCodeKey
            )
            : base(blockType, lenOfBlock) {
                this.BeginEffectTime    = _beginEffTime;
                this.EndEffectTime      = _endEffTime;
                this.CommtLevel         = commtLevel;
                this.CommtCodeKey       = commtCodeKey;
        }
        #endregion
    }
    #endregion

    #region Blockette type 052 //Channel Identifier Blockette
    /* [052]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  位置标示符    |  A    |    2    |     [UN]    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  通道标识符    |  A    |    3    |     [UN_]   |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  子通道标识符  |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  仪器标识符    |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  可选注释      |  V    |   0-30  |     [UNLPS] |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  信号响应单位  |  D    |    3    |       ###   |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  标定输入单位  |  D    |    3    |       ###   |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  纬度(度)      |  D    |    10   |-##.######   |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  经度(度)      |  D    |    11   |-###.######  |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  海拔(米)      |  D    |    7    |-####.#      |
     * +------|----------------|-------|---------+-------------+
     * | 13   |  深度(米)      |  D    |    5    | ###.#       |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  方位角(度)    |  D    |    5    | -##.#       |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  俯角(度)      |  D    |    5    | -##.#       |
     * +------|----------------|-------|---------|-------------+
     * | 16   |数据格式标识代码|  D    |    4    |       ####  |
     * +------|----------------|-------|---------|-------------+
     * | 17   |  数据记录长度  |  D    |    2    |       ##    |
     * +------|----------------|-------|---------|-------------+
     * | 18   |  采样频率      |  F    |    10   |  #.####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 19   |  最大时钟漂移  |  F    |    10   |  #.####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 20   |  注释分区块个数|  D    |    4    |  ####       |
     * +------|----------------|-------|---------|-------------+
     * | 21   |  通道类型标志  |  V    |    0-26 |  [U]        |
     * +------|----------------|-------|---------|-------------+
     * | 22   |  有效开始日期  |  V    |    1-22 |   TIME      |
     * +------|----------------|-------|---------|-------------+
     * | 23   |  有效结束日期  |  V    |    0-22 |   TIME      |
     * +------|----------------|-------|---------|-------------+
     * | 24   |  修改标志      |  A    |    1    |             |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 通道标识分区块[052]
    /// </summary>
    public class Block052 : For050N052 {
        #region fields of Block052
        private char[] locIdent             = new char[2]; // 2-Bytes;这里指台阵中每千点的位置标识符(台阵子代码)．台阵中的各点属于同一台阿
        private char[] chaIdent             = new char[3]; // 3-Bytes;通道标识符的规定见原文附录A
        private char[] channelFlags         = new char[26];
        private char[] optionalCommt        = new char[33];// 0-33 Bytes;可对仪器给出其它注释．如仪器的生产厂家、系列号等．
        private byte[] instrumtIdent        = new byte[3]; // 3B;D-Type;
        private byte[] unitsOfSignalResp    = new byte[3]; // 3B;D-Type;
        private byte[] unitsOfCalibratInput = new byte[3]; // 3B;D-Type;
        private byte[] localDepth           = new byte[5]; // 5B;D-Type;指井下仪的深度指地面下的深度或覆盖层的深度,地面仪器的深度可认为是零．
        private byte[] azimuth              = new byte[5]; // 5B;D-Type;指由北顺时针转动的角度。
        private byte[] dip                  = new byte[5]; // 5B;D-Type;指由水平面向下转的角度．
        private byte[] sampleRate           = new byte[10];//10B;F-Type;采样革单位为样本数／秒。这里不考虑漂移或时间校正。在规定的期间(如控制台日志或报警)不采样，则置零．
        private byte[] maxClockDrift        = new byte[10];//10B;F-Type;指最大时钟漂移存许值(阚值)．用一个记录中的样本数乘 本字段的值可计算出所容许的最太时间漂移。
                                                           //若一个记录中的时间差小于这个漂移值，则认为是相同的时间系列．
        #endregion

        #region properties of Block052
        public Int32 SubChaIdent        { get; set; }
        public Int32 DataFormatIdentCode{ get; set; }
        public Int16 DataRecordLength   { get; set; }
        public Int32 NumOfCommt         { get; set; }

        public string ChannelFlags {
            get {
                string _channelFlags = new string(channelFlags);
                return _channelFlags;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 26) ? 26 : len;
                for (int i = 0; i < len; i++) {
                    channelFlags[i] = str[i];
                }

            }
        }
        public string LocationIdent {
            get {
                string _locIdent = new string(locIdent);
                return _locIdent;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    locIdent[i] = str[i];
                }
            }

        }
        public string ChannelIdent {
            get {
                string _chaIdent = new string(chaIdent);
                return _chaIdent;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    chaIdent[i] = str[i];
                }
            }
        }
        public string OptionalCommt {
            get {
                string _optionalCommt = new string(optionalCommt);
                return _optionalCommt;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 33) ? 33 : len;
                for (int i = 0; i < len; i++) {
                    optionalCommt[i] = str[i];
                }
            }
        }
        public byte[] InstrumtIdent       {
            get {
                return this.instrumtIdent;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    instrumtIdent[i] = value[i];
                }
            }
        }
        public byte[] UnitsOfSignalResp   {
            get {
                return this.unitsOfSignalResp;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    unitsOfSignalResp[i] = value[i];
                }
            }
        }
        public byte[] UnitsOfCalibratInput{
            get {
                return this.unitsOfCalibratInput;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    unitsOfCalibratInput[i] = value[i];
                }
            }
        }
        public byte[] LocalDepth          {
            get {
                return this.localDepth;
            }
            set {
                int len = value.Length;
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    localDepth[i] = value[i];
                }
            }
        }
        public byte[] Azimuth             {
            get {
                return this.azimuth;
            }
            set {
                int len = value.Length;
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    azimuth[i] = value[i];
                }
            }
        }
        public byte[] Dip                 {
            get {
                return this.dip;
            }
            set {
                int len = value.Length;
                len = (len > 5) ? 5 : len;
                for (int i = 0; i < len; i++) {
                    dip[i] = value[i];
                }
            }
        }
        public byte[] SampleRate          {
            get {
                return this.sampleRate;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    sampleRate[i] = value[i];
                }
            }
        }
        public byte[] MaxClockDrift       {
            get {
                return this.maxClockDrift;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    maxClockDrift[i] = value[i];
                }
            }
        }
        #endregion

        #region constructors of Block052
        public Block052() { }
        public Block052(
            byte[]  blockType,
            Int32   lenOfBlock,
            byte[]  _latitude,
            byte[]  _longitude,
            byte[]  _elevation,
            string  _startDate,
            string  _endDate,
            char    updateFlag,
            string  _locIdent,            
            string  _chaIdent,            
            string  _channelFlags,       
            string  _optionalCommt,       
            byte[]  _instrumtIdent,       
            byte[]  _unitsOfSignalResp,   
            byte[]  _unitsOfCalibratInput,
            byte[]  _localDepth,          
            byte[]  _azimuth,             
            byte[]  _dip,                 
            byte[]  _sampleRate,          
            byte[]  _maxClockDrift,
            Int32   subChaIdent,        
            Int32   dataFormatIdentCode,
            Int16   dataRecordLength,   
            Int32   numOfCommt         
            )
            : base(blockType, lenOfBlock, _latitude, _longitude, _elevation, _startDate, _endDate, updateFlag) {
                this.LocationIdent          = _locIdent;
                this.ChannelIdent           = _chaIdent;
                this.ChannelFlags           = _channelFlags;
                this.OptionalCommt          = _optionalCommt;
                this.instrumtIdent          = _instrumtIdent;
                this.unitsOfSignalResp      = _unitsOfSignalResp;
                this.unitsOfCalibratInput   = _unitsOfCalibratInput;
                this.localDepth             = _localDepth;
                this.azimuth                = _azimuth;
                this.dip                    = _dip;
                this.sampleRate             = _sampleRate;
                this.maxClockDrift          = _maxClockDrift;
                this.SubChaIdent            = subChaIdent;
                this.DataFormatIdentCode    = dataFormatIdentCode;
                this.DataRecordLength       = dataRecordLength;
                this.NumOfCommt             = numOfCommt;
        }
        #endregion
    }
    #endregion

    #region Blockette type 053 //Response(Poles & Zeros) Blockette
    /* [053]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  传递函数类型  |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  阶顺序号      |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  AO归一因子    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  归一化频率    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  复零点个数    |  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  实零点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  虚零点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 12   |  实零点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 13   |  虚零点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  复极点个数    |  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  实极点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  虚极点        |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 17   |  实极点误差    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 18   |  虚极点误差    |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 响应(极点／零点)分区块[O53]:本分区块用于滤波系统的各模拟阶和无限脉冲响应(IIR)数字滤波器。
    /// 对于数字滤波器通常有数据抽取分区块[057]跟随其后，而且在许多阶迁有灵敏度／增益分区块[058]跟随其后。
    /// 考虑到新的地震系统中模拟和数字滤波相结合的情况，允许不同的反褶积算法按级联顺序进行。
    /// SEED对具有电于反馈电路的模拟仪器保留合成功能，阶的攻序与最韧的反褶积攻序相同-第一阶的信号输
    /// 入单位为地动单位．最后一阶的输出单位为数字计数。详细描述见原文附录C。
    /// </summary>
    public class Block053 : PolesNZeros {
        #region fields of Block053
        #endregion

        #region fields of Block053
        public char  TranserFuncType { get; set; }
        public Int16 StageSeqNum     { get; set; }
        #endregion

        #region fields of Block053
        public Block053() { }
        public Block053(byte[] blockType, Int32 lenOfBlock, char transferFuncType, Int16 stageSeqNum, Int32 respLookupKey, string _respName, char respType,
            byte[] stageSignalInputUnits, byte[] stageSignalOutputUnits,float[] aONormalizationFactor, 
            float[] normalizationFreq, byte[] numOfComplexZeros, List<float[]> realZero, List<float[]> imaginaryZero,
            List<float[]> realZeroError, List<float[]> imaginaryZeroError,byte[] numOfCompexPoles,
            List<float[]> realPole, List<float[]> imaginaryPole, List<float[]> realPoleError,List<float[]> imaginaryPoleError)
            : base(blockType, lenOfBlock, stageSignalInputUnits, stageSignalOutputUnits,aONormalizationFactor, 
            normalizationFreq, numOfComplexZeros,realZero, imaginaryZero, realZeroError, imaginaryZeroError,
            numOfCompexPoles, realPole, imaginaryPole, realPoleError, imaginaryPoleError) {
                this.TranserFuncType = transferFuncType;
                this.StageSeqNum     = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 054 //Response (Coefficients)Blockette
    /* [054]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  响应类型      |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  分子个数      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  分子系数      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  分子系数误差  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  分母个数      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  分母系数      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 12   |  分母系数误差  |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 响应(系数)分区块Eo54]
    /// 本分区块通常只用于表示有限脉冲响应(FIR)滤波器的各阶，
    /// 本分区块之后有分区块[057]或[058]跟随，
    /// 至此对堪被器的某一阶才算完成定义。若分区块的长度
    /// 超过9999个字符．可将多余的系数放在下一个记录中，
    /// 但要使两个记录中分区块的前几个字段完全一样．
    /// </summary>
    public class Block054 : Coefficients {
        #region fields of Block054
        #endregion

        #region fields of Block054
        public char  RespType    { get; set; }
        public Int16 StageSeqNum { get; set; }
        #endregion

        #region constructors of Block054
        public Block054() { }
        public Block054(
            byte[]  blockType, 
            Int32   lenOfBlock, 
            byte[]  signalInpuUnits, 
            byte[]  signalOutputUnits, 
            Int32   numOfNumerators, 
            List<float[]> numeratorCoeffi, 
            List<float[]> numeratorError,
            Int32   numOfDenominators, 
            List<float[]> denominatorCoeffi, 
            List<float[]> denominatorError,
            char    respType,
            Int16   stageSeqNum
            )
            : base(blockType, lenOfBlock, signalInpuUnits, signalOutputUnits, numeratorCoeffi,
            numeratorError, denominatorCoeffi, denominatorError, numOfNumerators, numOfDenominators) {
                this.RespType       = respType;
                this.StageSeqNum    = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 055 // Response List Blockette
    /* [055]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  列出的响应项目|  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  响应频率(Hz)  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  响应振幅      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  振幅误差      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  相位角(度)    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 11   |  相位角误差(度)|  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 响应目录分区块[055]
    /// 这不是一个标准的响应分区块，它不单独使用,要和
    /// 标准的响应分区块[053]、[056]、[057]或[058]同时
    /// 使用，然而它可以提供辅助的信息目录。
    /// </summary>
    public class Block055 : _List {
        #region fields of Block055
        #endregion

        #region properties of Block055
        public Int16 StageSeqNum { get; set; }
        #endregion

        #region constructors of Block055
        public Block055() { }
        public Block055(
            byte[]  blockType,
            Int32   lenOfBlock,
            byte[]  signalInputUnits,
            byte[]  signalOutputUnits,
            Int32   numOfRespListed,
            List<float[]> frequency,
            List<float[]> amplitude,
            List<float[]> amplitudeError,
            List<float[]> phaseAngle,
            List<float[]> phaseError,
            Int16   stageSeqNum
            )
            : base(blockType, lenOfBlock, signalInputUnits, signalOutputUnits, frequency,  
            amplitude, amplitudeError, phaseAngle, phaseAngle, numOfRespListed) {
                this.StageSeqNum = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 056 // Generic Response Blockette
    /* [056]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  拐角数目      |  D    |    4    |   ####      |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  拐角频率      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  拐角处斜率    |  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 一般响应分区块[056]
    /// 这也不是一个标准的响应分区块，它不单独使用,要
    /// 和标准的响应分区块[053]、[054]、[057]或[058]同
    /// 时使用，然而它可以提供辅助信息目录．
    /// </summary>
    public class Block056 : _Generic {
        #region fields of Block056
        #endregion

        #region properties of Block056
        public Int16 StageSeqNum { get; set; }
        #endregion

        #region constructors of Block056
        public Block056() { }
        public Block056(
            byte[] blockType,
            Int32 lenOfBlock,
            Int32 respLookupKey,
            string _respName,
            byte[] signalInputUnits,
            byte[] signalOutputUnits,
            Int32 numOfCornersListed,
            List<float[]> cornerFreq,
            List<float[]> cornerSlope,
            Int16   stageSeqNum
            )
            : base(blockType, lenOfBlock, signalInputUnits,
            signalOutputUnits, numOfCornersListed, cornerFreq, cornerSlope) {
                this.StageSeqNum = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 057 // Decimation Blockette
    /* [057]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  输入采样率    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  数据抽取因子  |  D    |    5    |   #####     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  抽取偏置      |  D    |    5    |   #####     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  估计延时(秒)  |  F    |    11   |-#.####E-##  |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  实际校正(秒)  |  F    |    11   |-#.####E-##  |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 数据抽取分区块[057]
    /// 许多数字滤波都要对高采样率数据流进行处理、滤波和数据抽取，
    /// 用以产生所要求的数据．车分区块用来描述滤渡器的每一阶的数据抽取情况。
    /// 它一般放在响应系数分区块[054]和通道灵敏度/增益分区块[055]之间。
    /// 非数据抽取的阶也要包含这一分区块，因为需要对时间
    /// 延时给予说明．(在这种情况下，抽取因数为1,偏置为0)
    /// </summary>
    public class Block057 : Decimation {
        public Int16 StageSeqNum { get; set; }

        #region constructors of Block057
        public Block057() { }
        public Block057(
            byte[]  blockType,
            Int32   lenOfBlock,
            byte[]  _inputSampleRate,
            byte[]  _decimationFactor,
            byte[]  _decimationOffset,
            byte[]  _estimatedDelay,
            byte[]  _correctionApplied,
            Int16   stageSeqNum
            )
            : base(blockType, lenOfBlock,_inputSampleRate,_decimationFactor,
            _decimationOffset, _estimatedDelay, _correctionApplied) {
                this.StageSeqNum = stageSeqNum;
        }

        #endregion
    }
    #endregion

    #region Blockette type 058 // Channel Sensitivety/Gain Blockette
    /* [058]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  灵敏度/增益   |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  频率(HZ)      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  历次标定的数目|  D    |    2    |   ##        |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  灵敏度标定    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  标定频率      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  标定时间      |  V    |    1-22 |     TIME    |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 通道是敬度/增益分区块[058]
    /// 本分区块在描述通道灵敏度和通道增益时有不同的形式。
    /// 若用来描述增益，指的是某一阶在给定将率时的增益，
    /// 各阶对应的频率可能不同，但SEED极力推荐所有阶(级联的)培定的频率尽可能相同；
    /// 若用来描述灵敏度，指的是在给定频率时整个通道的是敏度．
    /// </summary>
    public class Block058 : SensitivityNGain {
        #region fields of Block058
        #endregion

        #region properties of Block058
        public Int16 StageSeqNum { get; set; }
        #endregion

        #region constructors of Block058
        public Block058() { }
        public Block058(
            byte[]  blockType,
            Int32   lenOfBlock,
            List<char[]>  _timeOfAboveCalibration,
            float[] _sensitivityNGain,      
            float[] _frequency,             
            List<float[]> _sensitForCalibration,  
            List<float[]> _freqOfCalibrationSens,
            Int16   stageSeqNum
            )
            : base(blockType,lenOfBlock,_timeOfAboveCalibration,
            _sensitivityNGain, _frequency, _sensitForCalibration, _freqOfCalibrationSens) {
                this.StageSeqNum = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 060 // Response Reference Blockette
    /* [060]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  阶数          |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  阶的顺序号    |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  响应数目      |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  响应查询代码  |  D    |    4    |     ####    |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 响应引用分区块[O60]
    /// 这是一个可选分区块，利用它，在任何时候都可以用分区块[041]、[043]到[O48]
    /// 分别代替分区块[O61]、[053]到[0S8]。完成替代过程要按阶的次序进行，即使这样儆需要多次用到响应引用分区块[060]，
    /// 但这是SEED推荐的方式。引入分区块[060]的位置是任意的，但必须确保使替代的分区块与原分区块处于相同的位置。
    /// </summary>
    public class Block060 : Block {
        #region fields of Block060
        private List<Int16> stageSeqNum   = new List<short>();
        private List<Int32> respLookupKey = new List<int>();
        #endregion
        #region properties of Block060
        public Int16 NumOfStages    { get; set; }// 2-Bytes;
        public Int16 NumOfResp      { get; set; }// 2-Bytes;
        public List<Int16> StageSeqNum {
            get {
                return this.stageSeqNum;
            }
            set {
                for (int i = 0; i < NumOfStages; i++) {
                    this.StageSeqNum.Add(value[i]);
                }
            }
        }
        public List<Int32> RespLookupKey {
            get {
                return this.respLookupKey;
            }
            set {
                for (int i = 0; i < NumOfResp; i++) {
                    this.respLookupKey.Add(value[i]);
                }
            }
        }
        #endregion

        #region constructors of Block060
        public Block060() { }
        public Block060(byte[] blockType,Int32 lenOfBlock,
            Int16 numOfStages, List<Int16> stageSeqNum, Int16 numOfResp, List<Int32> respLookepKey) {
                this.NumOfStages    = numOfStages;
                this.StageSeqNum    = stageSeqNum;
                this.NumOfResp      = numOfResp;
                this.RespLookupKey  = respLookepKey;
        }
        #endregion

    }
    #endregion

    #region Blockette type 061 // FIR Response Blockette
    /* [061]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    | 阶的顺序号     |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  响应名称      |  V    |    1-25 |     [UN]    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  对称性代码    |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  输入信号单位  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  输出信号单位  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  因子个数      |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  FIR系数       |  F    |    14   |-#.######E-##|
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// FIR响应分区块[061]
    /// FIR响应分区块用来说明有限脉冲响应数字滤波器的系数，
    /// 它能代替响应系数分区块[054]。该分区块可以区分滤波器对称性的不同类型,
    /// 并利用对称性来缩减分区块内所要列出的系数数目。
    /// </summary>
    public class Block061 : FIR {
        #region properties of Block061
        public Int16 StageSeqNum { get; set; }
        #endregion

        #region constructors of Block061
        public Block061() { }
        public Block061(
            byte[] blockType,
            Int32  lenOfBlock,
            Int16 stageSeqNum,
            char[] _respName,
            Char   symmetryCode,
            byte[] _signalInUnits,
            byte[] _signalOutUnits,
            Int32 numOfCoefficients,
            List<byte[]> _FIRCoefficient
            )
            : base(blockType, lenOfBlock, _respName, _signalInUnits, 
            _signalOutUnits, symmetryCode, numOfCoefficients,_FIRCoefficient) {
                this.StageSeqNum = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 062 // Response[Polynomial] Blockette
    /* [062]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  传递函数类型  |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  接序列号      |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  阶输入信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  阶输出信号单位|  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  多项式逼近类型|  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  有效频率单位  |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  有效频率下界  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  有效频率上界  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  逼近下界      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------+-------------+
     * | 12   |  逼近上界      |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 13   |  最大绝对误差  |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  多项式系数个数|  D    |    3    |   ###       |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  多项式系数    |  F    |    12   |-#.#####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  多项式系数误差|  F    |    12   |-#.#####E-## |
     * +-------------------------------------------------------+ 
     */
    /// <summary>
    /// 响应(多项式)分区块[062]
    /// 使用本分区块来刻画一个非线性的传感器响应。多项式分区块本质上与其它响应分区块不同，他描述的是地球敏感器的输出
    /// 详细信息请参考SEED Manual V2.4
    /// </summary>
    public class Block062 : Polynomial {
        public Int16 StageSeqNum { get; set; }
        #region constructors of Block062
        public Block062() { }
        public Block062(byte[] blockType,Int32 lenOfBlock,char transFuncType,Int16 stageSeqNum,
            byte[] _stageSignalInutUnits,byte[] _stageSignalOutputUnites,char polyApproxType,char validFreqUnits,
            float[] _lowerValidFreqBound,float[] _upperValidFreqBound,float[] _lowerBoundOfApprox,
            float[] _upperBoundOfApprox,float[] _maxAbsoluteError,byte[] _numOfPolyCoeffi,
            List<float[]> _polyCoeffi, List<float[]> _polyCoeffiError)
            : base(blockType, lenOfBlock, transFuncType, _stageSignalInutUnits, _stageSignalOutputUnites,
            polyApproxType, validFreqUnits, _lowerValidFreqBound, _upperValidFreqBound, _lowerBoundOfApprox,
            _upperBoundOfApprox, _maxAbsoluteError, _numOfPolyCoeffi, _polyCoeffi, _polyCoeffiError) {
                this.StageSeqNum = stageSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 070 //Time Span Identifier Blockette
    /* [070]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  时间片标志    |  A    |    1    |     [U]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |时间片开始时间  |  V    |    1-22 |     TIME    |
     * +------|----------------|-------|---------|-------------+
     * | 5    |时间片结束时间  |  V    |    1-22 |     TIME    |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 时间片标识分区块[07O]
    /// 这个分区块用来描连时间片的开始时间 结束时间以及时间片数据是否为事件等。
    /// </summary>
    public class Block070 : Block {
        #region fields of Block070
        private char[] beginTimeOfDataSpan  = new char[22];
        private char[] endTimeOfDataSpan    = new char[22];
        #endregion

        #region fields of Block070
        public char TimeSpanFlag { get; set; }
        public string BeginTimeOfDataSpan {
            get {
                string _beginTimeOfDateSpan = new string(beginTimeOfDataSpan);
                return _beginTimeOfDateSpan;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    beginTimeOfDataSpan[i] = str[i];
                }
            }
        }
        public string EndTimeOfDataSpan {
            get {
                string _endTimeOfDataSpan = new string(endTimeOfDataSpan);
                return _endTimeOfDataSpan;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    endTimeOfDataSpan[i] = str[i];
                }
            }
        }
        #endregion

        #region fields of Block070
        public Block070() { }
        public Block070(byte[] blockType, Int32 lenOfBlock, 
            char timeSpanFlag,string _begTimeOfDataSpan, string _endTimeOfDataSpan)
            : base(blockType, lenOfBlock) {
                this.TimeSpanFlag = timeSpanFlag;
                this.BeginTimeOfDataSpan = _begTimeOfDataSpan;
                this.EndTimeOfDataSpan   = _endTimeOfDataSpan;
        }
        #endregion
    }
    #endregion

    #region Blockette type 071 // Hypocenter Information Blockette
    /* [071]块结构：
     * +-------------------------------------------------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  时间发震时刻  |  V    |   1-22  |     TIME    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  震源出处标识  |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  事件纬度(度)  |  D    |    10   |  -##.###### |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  事件经度(度)  |  D    |    11   |  -###.######|
     * +------|----------------|-------|---------|-------------+
     * | 7    |  事件深度(公里)|  D    |    7    | #######     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  震源级数      |  D    |    2    |  ##         |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  震级          |  D    |    5    |   #####     |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  震级类型      |  V    |    1-10 |  [UNLPS]    |
     * +------|----------------|-------|---------+-------------+
     * | 11   |  震级出处      |  D    |    2    |   ##        |
     * +------|----------------|-------|---------+-------------+
     * | 12   |  震级区域      |  D    |    3    |   ###       |
     * +------|----------------|-------|---------+-------------+
     * | 13   |  震级地理位置  |  D    |    4    |    ####     |
     * +------|----------------|-------|---------+-------------+
     * | 14   |  区域名称      |  V    |    1-40 |  [UNLPS]    |
     * +-------------------------------------------------------+
     */
    /// <summary>
    /// 震源信息分区块[071]
    /// 本分区块用于事件卷，台网卷可选用
    /// </summary>
    public class Block071 : Block {
        #region fields of Block071
        private char[] originTimeOfEvent    = new char[22];// 1-22 Bytes;The event’s origin time.
        private byte[] latitudeOfEvent      = new byte[10];// 10B; D-Type;
        private byte[] longitudeOfEvent     = new byte[11];// 11B; D-Type;
        private byte[] depth                = new byte[7]; // 7B;  D-Type;
        private List<char[]> magnitudeType        = new List<char[]>();// 1-10 Bytes;The magnitude type (MB, Msz, etc.)
        private List<char[]> regionName           = new List<char[]>();// 1-40 Bytes;The Flinn-Engdahl standard place name.
        private List<byte[]> magnitude            = new List<byte[]>(); // 5B;  D-Type;
        private List<byte[]> seismicRegion        = new List<byte[]>(); // 3B;  D-Type;
        #endregion

        #region properties of Block071
        public Int16 NumOfMagnitudes        { get; set; }// 2-Bytes;The number of magnitude listings that follow
        public Int16 HypocenterSourceIden   { get; set; }// 2-Bytes;The source quoted for the hypocenter information. Use a source lookup code key that refers to field 3 of the Cited
                                                         //Source Dictionary Blockette [32], where the source reference is located.
        public List<Int32> SeismicLocation        { get; set; }// 4-Bytes;The Flinn-Engdahl seismic location number. Refers to Earth place names.
        public List<Int16> MagnitudeSource        { get; set; }// 2-Bytes;Reference for the magnitude. This field may be set to zero if it is the same as the value in field 4, 
                                                               //above. Otherwise,use a source lookup code key that refers to field 3 of the Cited Source Dictionary Blockette [32], 
                                                               //where the source reference is located.
        public byte[] LatitudeOfEvent       {
            get {
                return this.latitudeOfEvent;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.latitudeOfEvent[i] = value[i];
                }
            }
        }
        public byte[] LongitudeOfEvent      {
            get {
                return this.longitudeOfEvent;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.longitudeOfEvent[i] = value[i];
                }
            }
        }
        public byte[] Depth                 {
            get {
                return this.depth;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this.depth[i] = value[i];
                }
            }
        }
        public List<byte[]> Magnitude             {
            get {
                return this.magnitude;
            }
            set {
                for (int index = 0; index < NumOfMagnitudes; index++) {
                    byte[] _magnitude = new byte[3];
                    int len = value[index].Length;
                    len = (len > 3) ? 3 : len;
                    for (int i = 0; i < len; i++) {
                        _magnitude[i] = value[index][i];
                    }
                    this.magnitude.Add(_magnitude);
                }
            }
        }
        public List<byte[]> SeismicRegion         {
            get {
                return this.seismicRegion;
            }
            set {
                for (int index = 0; index < NumOfMagnitudes; index++) {
                    byte[] _seismicRegion = new byte[3];
                    int len = value[index].Length;
                    len = (len > 3) ? 3 : len;
                    for (int i = 0; i < len; i++) {
                        _seismicRegion[i] = value[index][i];
                    }
                    this.seismicRegion.Add(_seismicRegion);
                }
            }
        }
        public string OriginTimeOfEvent {
            get {
                string _originTimeOfEvent = new string(originTimeOfEvent);
                return _originTimeOfEvent;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    originTimeOfEvent[i] = str[i];
                }
            }
        }
        public List<char[]> MagnitudeType {
            get {
                return magnitudeType;
            }
            set {
                for (int index = 0; index < NumOfMagnitudes; index++) {
                    int len = value[index].Length;
                    len = (len > 10) ? 10 : len;
                    char[] _magnitudeType = new char[len];
                    for (int i = 0; i < len; i++) {
                        _magnitudeType[i] = value[index][i] ;
                    }
                    this.magnitudeType.Add(_magnitudeType);
                }
                
            }
        }
        public List<char[]> RegionName {
            get {
                return regionName;
            }
            set {
                for (int index = 0; index < NumOfMagnitudes; index++) {
                    int len = value[index].Length;
                    len = (len > 10) ? 10 : len;
                    char[] _regionName = new char[len];
                    for (int i = 0; i < len; i++) {
                        _regionName[i] = value[index][i];
                    }
                    this.regionName.Add(_regionName);
                }

            }
        }
        #endregion

        #region properties of Block071
        public Block071() { }
        public Block071(
            byte[]  blockType,
            Int32   lenOfBlock,
            string  originTimeOfEvent,
            Int16   hypSourceIndentifier,
            byte[]  _latitudeOfEvent,
            byte[]  _longitudeOfEvent,
            byte[]  _depth,
            Int16   numOfMagnitudes,
            List<byte[]>  _magnitude,
            List<char[]>  magnitudeType,
            List<Int16>   _magnitudeSource,
            List<byte[]>  _seismicRegion,
            List<Int32>   seismicLocation,
            List<char[]>  regionName
            )
            : base(blockType, lenOfBlock) {
                this.OriginTimeOfEvent      = originTimeOfEvent;
                this.HypocenterSourceIden   = hypSourceIndentifier;
                this.latitudeOfEvent        = _latitudeOfEvent;
                this.longitudeOfEvent       = _longitudeOfEvent;
                this.depth              = _depth;
                this.NumOfMagnitudes    = numOfMagnitudes;
                this.magnitude          = _magnitude;
                this.MagnitudeType      = magnitudeType;
                this.MagnitudeSource    = _magnitudeSource;
                this.SeismicRegion      = _seismicRegion;
                this.SeismicLocation    = seismicLocation;
                this.RegionName         = regionName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 072 // Event Phases Blockette
    /* [072]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  台站标识符    |  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  位置标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  震相到时      |  V    |    1-22 |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  信号幅度      |  F    |    10   |  #.####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 8    |  信号周期(秒)  |  F    |    10   |  #.####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  信噪比        |  F    |    10   |  #.####E-## |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  震相名        |  V    |    1-20 |  [UNLP]     |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  震相出处      |  D    |    2    |  ##         |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  台网代码      |  A    |    2    |  [UN]       |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 事件震相分区块[072]
    /// 本分区块给出不同台站的震相到时
    /// </summary>
    public class Block072 : IndentBlock {
        #region fields of Block072
        private char[] arrivalTimeOfPhase   = new char[22];// 1-22 Bytes;Phase arrival time at the station.
        private byte[] amplitudeOfSignal    = new byte[10];// 10B;F-Type;
        private byte[] periodOfSignal       = new byte[10];// 10B;F-Type;
        private byte[] signalToNoiseRatio   = new byte[10];// 10B;F-Type;
        private char[] nameOfPhase          = new char[20];// 1-20 Bytes;The standard name of the phase. Station event pickers can use the “P” phase.
        private char[] networkCode          = new char[2]; // 2-Bytes;The two character identifier that identifies the network operator.
        #endregion

        #region properties of Block072
        public Int16 Source { get; set; }
        public byte[] AmplitudeOfSignal  {
            get {
                return this.amplitudeOfSignal;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    this.amplitudeOfSignal[i] = value[i];
                }
            }
        }
        public byte[] PeriodOfSignal     {
            get {
                return this.periodOfSignal;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    this.periodOfSignal[i] = value[i];
                }
            }
        }
        public byte[] SignalToNoiseRatio {
            get {
                return this.signalToNoiseRatio;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    this.signalToNoiseRatio[i] = value[i];
                }
            }
        }
        public string ArrivalTimeOfPhase {
            get {
                string _arriTimeOfPhase = new string(arrivalTimeOfPhase);
                return _arriTimeOfPhase;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    arrivalTimeOfPhase[i] = str[i];
                }
            }
        }
        public string NameOfPhase {
            get {
                string _nameOfPhase = new string(nameOfPhase);
                return _nameOfPhase;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 20) ? 20 : len;
                for (int i = 0; i < len; i++) {
                    nameOfPhase[i] = str[i];
                }
            }
        }
        public string NetworkCode {
            get {
                string _networdCode = new string(networkCode);
                return _networdCode;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 2) ? 2 : len;
                for (int i = 0; i < len; i++) {
                    networkCode[i] = str[i];
                }
            }
        }
        #endregion

        #region constructors of Block072
        public Block072() { }
        public Block072(
            byte[] blockType,
            Int32  lenOfBlock,
            string staIdentifier,     
            string locationIden,      
            string channelIden,       
            string arrivalTimeOfPhase,
            byte[] amplitudeOfSignal, 
            byte[] periodOfSignal,    
            byte[] signalToNoiseRatio,
            string nameOfPhase,
            Int16  source,
            string networkCode       
            )
            : base(blockType, lenOfBlock,staIdentifier,locationIden,channelIden) {
                this.ArrivalTimeOfPhase = arrivalTimeOfPhase;
                this.ArrivalTimeOfPhase = arrivalTimeOfPhase;
                this.AmplitudeOfSignal  = amplitudeOfSignal;
                this.PeriodOfSignal     = periodOfSignal;
                this.SignalToNoiseRatio = signalToNoiseRatio;
                this.NameOfPhase        = nameOfPhase;
                this.Source             = source;
                this.NetworkCode        = networkCode;
        }
        #endregion
    }
    #endregion

    #region Blockette type 073 // Time Span Data Start Index Blockette
    /* [073]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  数据段个数    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 4    |数据段台站标识符|  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  位置标识符    |  A    |    2    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  记录时间      |  V    |    1-22 |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 8    |第一个记录顺序号|  D    |    6    |    ######   |//第一个数据记录顺序号
     * +------|----------------|-------|---------|-------------+
     * | 9    | 子顺序号       |  D    |    2    |     ##      |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 时间片数据开始索引分区块[073]
    /// 本分区块记录了时间片中不同的时间序列的有关信
    /// 息,对于每一个时间片都有一个索引入口。本分区块只用
    /// 于SEED 2．0版本 2 3版本不用它，但读程序能读它
    /// </summary>
    public class Block073 : RptIndentBlock {
        #region fields of Block073
        private List<char[]> timeOfRecord         = new List<char[]>();// 1-22 Bytes;The time when this time series starts (same as the start time for the record).
        private List<byte[]> seqNumOfFirstRecord  = new List<byte[]>();// 6-Bytes;The data sequence number of the data record.
        #endregion

        #region properties of Block073
        public Int32 NumOfDataPieces { get; set; }
        public List<Int16> SubSeqNum { get; set; }// 2-Bytes;The sub-sequence number, used when the data record size is less than the logical record size. 
                                                  //Number the first data record in the logical record “1.”
        public List<char[]> TimeOfRecord {
            get {
                return timeOfRecord;
            }
            set {
                for (int index = 0; index < NumOfDataPieces; index++) {
                    int len = value[index].Length;
                    len = (len > 22) ? 22 : len;
                    char[] _timeOfRecord = new char[len];
                    for (int i = 0; i < len; i++) {
                        _timeOfRecord[i] = value[index][i];
                    }
                    this.timeOfRecord.Add(_timeOfRecord);
                }
            }
        }
        public List<byte[]> SeqNumOfFirstRecord {
            get {
                return this.seqNumOfFirstRecord;
            }
            set {
                for (int index = 0; index < NumOfDataPieces; index++) {
                    byte[] _seqNumOfFirstRecord = new byte[6];
                    int len = value[index].Length;
                    len = (len > 6) ? 6 : len;
                    for (int i = 0; i < len; i++) {
                        _seqNumOfFirstRecord[i] = value[index][i];
                    }
                    this.seqNumOfFirstRecord.Add(_seqNumOfFirstRecord);
                }
            }
        }
        #endregion

        #region constructors of Block073
        public Block073() { }
        public Block073(
            byte[] blockType,
            Int32  lenOfBlock,
            List<char[]> staIdentifier,     
            List<char[]> locationIden,      
            List<char[]> channelIden,
            Int32  numOfDataPieces,
            List<char[]> timeOfRecord,
            List<byte[]> seqNumOfFirstRecord,
            List<Int16>  subSeqNum
            )
            : base(blockType, lenOfBlock,numOfDataPieces, staIdentifier, locationIden, channelIden) {
                this.NumOfDataPieces     = numOfDataPieces;
                this.TimeOfRecord        = timeOfRecord;
                this.SeqNumOfFirstRecord = seqNumOfFirstRecord;
                this.SubSeqNum           = subSeqNum;
        }
        #endregion
    }
    #endregion

    #region Blockette type 074 //Time Series Index Blockette
    /* [074]块结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    |  分区块类型码  |  D    |    3    |     ###     |
     * +------|----------------|-------|---------|-------------+
     * | 2    |  分区块长度    |  D    |    4    |     ####    |
     * +------|----------------|-------|---------|-------------+
     * | 3    |  台站标识符    |  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 4    |  位置标识符    |  A    |    2    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |时间序列开始时间|  V    |    1-22 |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |第一个记录顺序号|  D    |     6   |  ######     |//第一个数据记录顺序号
     * +------|----------------|-------|---------|-------------+
     * | 8    |  子顺序号      |  D    |    2    |  ##         |
     * +------|----------------|-------|---------|-------------+
     * | 9    |时间序列结束时间|  V    |    1-22 |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 10   |最后数据记录序号|  D    |     6   |  ######     |//最后一个数据记录顺序号
     * +------|----------------|-------|---------|-------------+
     * | 11   |  子顺序号      |  D    |    2    |  ##         |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  加速器数目    |  D    |    3    |  ###        |
     * +------|----------------|-------|---------|-------------+
     * | 13   |  记录开始时间  |  V    |    1-22 |    TIME     |
     * +------|----------------|-------|---------|-------------+
     * | 14   | 数据记录顺序号 |  D    |     6   |  ######     |
     * +------|----------------|-------|---------|-------------+
     * | 15   |  子顺序号      |  D    |    2    |  ##         | 
     * +------|----------------|-------|---------|-------------+
     * | 16   |  台网代码      |  A    |    2    |  [UN]       |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 时间序列索引分区块[074]
    /// 在SEED2．i版本中已用本分区块代替了分区块
    /// [073]．对于每一个连续的时间序列都应有一个时间序列
    /// 索引分区抉[074]与其对应，它对所描述的时间序列提
    /// 供索引和开始及结柬时间．
    /// </summary>
    public class Block074 : IndentBlock {
        #region fields of Block074
        private char[] seriesStartTime      = new char[22];// 1-22 Bytes;The time when this time series starts (same as the start time for the first record).
        private byte[] seqNumOfFirstData    = new byte[6]; // 6-Bytes;
        private char[] seriesEndTime        = new char[22];// 1-22 Bytes;The time when this time series ends (same as the end time for the last record).
        private byte[] seqNumOfLastRecord   = new byte[6]; // 6B;D-Type;
        private byte[] numOfAccRepeats      = new byte[3]; // 3B;E-Type;
        private List<char[]> networkCode          = new List<char[]>(); // 2-Bytes;The two character identifier that identifies the network operator.
        private List<char[]> recordStartTime      = new List<char[]>();// 1-22 Bytes;The start time of the record to which the accelerator index refers.
        private List<byte[]> seqNumOfRecord       = new List<byte[]>(); // 6B;D-Type;
        #endregion

        #region properties of Block074
        public Int16 SubSeqNum_1 { get; set; }
        public Int16 SubSeqNum_2 { get; set; }
        public List<Int16> SubSeqNum_3   { get; set; }
        //以下只读私有属性只是本类中使用到
        private Int32 Count {
            get {
                // If the system architecture is little-endian (that is, little end first),
                // reverse the byte array.
                if (BitConverter.IsLittleEndian)
                    Array.Reverse(this.numOfAccRepeats);
                return BitConverter.ToInt32(this.numOfAccRepeats, 0);
            }
        }
        public byte[] SeqNumOfLastRecord {
            get {
                return this.seqNumOfLastRecord;
            }
            set {
                int len = value.Length;
                len = (len > 6) ? 6 : len;
                for (int i = 0; i < len; i++) {
                    this.seqNumOfLastRecord[i] = value[i];
                }
            }
        }
        public byte[] NumOfAccRepeats {
            get {
                return this.numOfAccRepeats;
            }
            set {
                int len = value.Length;
                len = (len > 6) ? 6 : len;
                for (int i = 0; i < len; i++) {
                    this.numOfAccRepeats[i] = value[i];
                }
            }
        }
        public List<byte[]> SeqNumOfRecord {
            get {
                return this.seqNumOfRecord;
            }
            set {
                for (int index = 0; index < Count; index++) {
                    byte[] _seqNumOfRecord = new byte[6];
                    int len = value[index].Length;
                    len = (len > 6) ? 6 : len;
                    for (int i = 0; i < len; i++) {
                        _seqNumOfRecord[i] = value[index][i];
                    }
                    this.seqNumOfRecord.Add(_seqNumOfRecord);
                }
            }
        }
        public string SeriesStartTime {
            get {
                string _seriesStartTime = new string(seriesStartTime);
                return _seriesStartTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    seriesStartTime[i] = str[i];
                }
            }
        }
        public string SeriesEndTime {
            get {
                string _seriesEndTime = new string(seriesEndTime);
                return _seriesEndTime;
            }
            set {
                int len = value.Length;
                char[] str = new char[len];
                str = value.ToCharArray();
                len = (len > 22) ? 22 : len;
                for (int i = 0; i < len; i++) {
                    seriesEndTime[i] = str[i];
                }
            }
        }
        public List<char[]> RecordStartTime {
            get {
                return recordStartTime;
            }
            set {
                for (int index = 0; index < Count; index++) {
                    int len = value[index].Length;
                    len = (len > 22) ? 22 : len;
                    char[] _recordStartTime = new char[len];
                    for (int i = 0; i < len; i++) {
                        _recordStartTime[i] = value[index][i];
                    }
                    this.recordStartTime.Add(_recordStartTime);
                }
            }
        }
        public List<char[]> NetworkCode {
            get {
                return networkCode;
            }
            set
            {
                for (int index = 0; index < Count; index++)
                {
                    char[] _networkCode = new char[2];//这里是定长的
                    int len = value[index].Length;
                    len = (len > 2) ? 2 : len;
                    //char[] _recordStartTime = new char[len];//这里是变长的
                    for (int i = 0; i < len; i++)
                    {
                        _networkCode[i] = value[index][i];
                    }
                    this.networkCode.Add(_networkCode);
                }
            }
        }
        #endregion

        #region properties of Block074
        public Block074() { }
        public Block074(
            byte[] blockType,
            Int32  lenOfBlock,
            string staIdentifier,     
            string locationIden,      
            string channelIden,
            string seriesStartTime,
            byte[] seqNumOfFirstData,
            Int16  subSeqNum_1,
            string seriesEndTime,
            byte[] seqNumOfLastRecord,
            Int16  subSeqNum_2,
            byte[] numOfAccRepeats,
            List<char[]> recordStartTime,
            List<byte[]> seqNumOfRecord,
            List<Int16>  subSeqNum_3,
            List<char[]> networkCode
            )
            : base(blockType, lenOfBlock, staIdentifier, locationIden, channelIden) {
                this.SeriesStartTime    = seriesStartTime;
                this.seqNumOfFirstData  = seqNumOfFirstData;
                this.SubSeqNum_1        = subSeqNum_1;
                this.SeriesEndTime      = seriesEndTime;
                this.SeqNumOfLastRecord = seqNumOfLastRecord;
                this.SubSeqNum_2        = subSeqNum_2;
                this.NumOfAccRepeats    = numOfAccRepeats;
                this.RecordStartTime    = recordStartTime;
                this.SeqNumOfRecord     = seqNumOfRecord;
                this.SubSeqNum_3        = subSeqNum_3;
                this.NetworkCode        = networkCode;
        }
        #endregion
    }
    #endregion

    #region Fixed Section of Data Header(48 bytes)
    /* 数据记录固定头段结构：
     * +------|----------------|-------|---------|-------------+
     * |字段号|     字段名     |  类型 |  长度   |表征码/特征码|
     * +------|----------------|-------|---------|-------------+
     * | 1    | 数据记录顺序号 |  D    |    6    |  ######     |
     * +------|----------------|-------|---------|-------------+
     * | 2    | 数据头段标识符 |  A    |    1    |             |//用"D"表示
     * +------|----------------|-------|---------|-------------+
     * | 3    | 保留字节       |  A    |    1    |             |//用空格表示
     * +------|----------------|-------|---------|-------------+
     * | 4    |  台站标识符    |  A    |    5    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 5    |  位置标识符    |  A    |    2    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 6    |  通道标识符    |  A    |    3    |    [UN]     |
     * +------|----------------|-------|---------|-------------+
     * | 7    |  台网代码      |  A    |    2    |             |
     * +------|----------------|-------|---------|-------------+
     * | 8    |数据记录开始时间|  B    |    10   |             |
     * +------|----------------|-------|---------|-------------+
     * | 9    |  数据记录样本数|  B    |    2    |             |
     * +------|----------------|-------|---------|-------------+
     * | 10   |  采样率系数    |  B    |    2    |             |
     * +------|----------------|-------|---------|-------------+
     * | 11   |  采样率因子    |  B    |    2    |             |
     * +------|----------------|-------|---------|-------------+
     * | 12   |  活动标志      |  B    |    1    |             |
     * +------|----------------|-------|---------|-------------+
     * | 13   |  I/O和时钟标志 |  B    |    1    |             |
     * +------|----------------|-------|---------|-------------+
     * | 14   |  数据质量标志  |  B    |    1    |             |
     * +------|----------------|-------|---------|-------------+
     * | 15   | 后跟分区块总数 |  B    |    1    |             |
     * +------|----------------|-------|---------|-------------+
     * | 16   |  时间校正      |  B    |    4    |             |
     * +------|----------------|-------|---------|-------------+
     * | 17   |数据开始的字节数|  B    |    2    |             |
     * +------|----------------|-------|---------|-------------+
     * | 18   |第一个分区块开始|  B    |    2    |             |
     * |      |   的字节数     |       |         |             |
     * +------|----------------|-------|---------|-------------+
     */
    /// <summary>
    /// 数据记录固定头段
    /// </summary>
    public class FixedSection {
        #region The fields of fixed section of data header
        private byte[] seqNum       = new byte[6];//6B;D-type;
        private char[] staIC        = new char[5];//Station identifier code:5B
        private char[] locationID   = new char[2];//Location identifier:2B
        private char[] channelID    = new char[3];//Channel identifier:2B
        private char[] netCode      = new char[2];//Network Code:2B
        #endregion

        #region The properties of fixed section of data header
        public char     DataHQualityIndicator   { get; set; }//Data header/quality indicator:1B
        public char     ReservedByte            { get; set; }//Reserved byte:1B
        public DateTime RecordStartTime         { get; set; }//Record Start Time:10B
        public Int16    NumberOfSamples         { get; set; }//Number Of Samples:2B
        public Int16    SampleRateFactor        { get; set; }//Sample rate factor:2B
        public Int16    SampleRateMultipiler    { get; set; }//Sample rate multiplier:2B
        public Byte     ActivityFlags           { get; set; }//Activity flags:1B
        public Byte     IOandClockFlags         { get; set; }//I/O and clock flags:1B
        public Byte     DataQualityFlags        { get; set; }//Data quality flags:1B
        public Byte     NumberOfBlockettes      { get; set; }//Number of blockettes that follow:1B
        public float    TimeCorrection          { get; set; }//Time correction:4B
        public Int16    BeginningOfData         { get; set; }//Beginning of data:2B
        public Int16    FirstBlockette          { get; set; }//First blockette:2B

        public byte[] SequenceNum {
            get {
                return this.seqNum;
            }
            set {
                int len = value.Length;
                len = (len > 6) ? 6 : len;
                for (int i = 0; i < len; i++) {
                    this.seqNum[i] = value[i];
                }
            }
        }
        public string StationIC {   //Station identifier code:5B                          
            get {
                string _staIC = new string(staIC);
                return _staIC;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (5 < Len) ? 5 : Len;
                for (int i = 0; i < Len; i++)
                    staIC[i] = str[i];
            }
        }
        public string LocationID {    //Location identifier:2B                      
            get {
                string _locationID = new string(locationID);
                return _locationID;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (2 < Len) ? 2 : Len;
                for (int i = 0; i < Len; i++)
                    locationID[i] = str[i];
            }
        }
        public string ChannelID {    //Channel identifier:2B
            get {
                string _channelID = new string(channelID);
                return _channelID;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (3 < Len) ? 3 : Len;
                for (int i = 0; i < Len; i++)
                    channelID[i] = str[i];
            }
        }
        public string NetCode {   //Network Code:2B
            get {
                string _netCode = new string(netCode);
                return _netCode;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (2 < Len) ? 2 : Len;
                for (int i = 0; i < Len; i++)
                    netCode[i] = str[i];
            }
        }
        #endregion

        #region constuctors of fixed section of data header
        public FixedSection() { }
        public FixedSection(
            byte[]   _seqNum,
            char     dataHQualityIndicator,
            char     reservedByte,
            string   staIdentCode,
            string   locIdent,
            string   chaIdent,
            string   netCode,
            DateTime recordStartTime,      
            Int16    numberOfSamples,      
            Int16    sampleRateFactor,     
            Int16    sampleRateMultipiler, 
            Byte     activityFlags,        
            Byte     iOandClockFlags,      
            Byte     dataQualityFlags,     
            Byte     numberOfBlockettes,   
            float    timeCorrection,       
            Int16    beginningOfData,      
            Int16    firstBlockette
            ) {
                this.SequenceNum            = _seqNum;
                this.DataHQualityIndicator  = dataHQualityIndicator;
                this.ReservedByte           = reservedByte;
                this.StationIC              = staIdentCode;
                this.LocationID             = locIdent;
                this.ChannelID              = chaIdent;
                this.NetCode                = netCode;
                this.RecordStartTime        = recordStartTime;
                this.NumberOfSamples        = numberOfBlockettes;
                this.SampleRateFactor       = sampleRateFactor;
                this.ActivityFlags          = activityFlags;
                this.IOandClockFlags        = iOandClockFlags;
                this.DataQualityFlags       = dataQualityFlags;
                this.NumberOfBlockettes     = numberOfBlockettes;
                this.TimeCorrection         = timeCorrection;
                this.BeginningOfData        = beginningOfData;
                this.FirstBlockette         = firstBlockette;
        }
        #endregion
    }
    #endregion

    #region Blockette type 100 //Sample Rate Blockette(12 bytes)
    /* 采样分区块[100]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 实际采样率         |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  4   | 标志               |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 保留字节           |  B    |   3     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 采样率分区块[100]
    /// </summary>
    public class Block100 : NBlock {
        private byte[] _reservedByte = new byte[3];

        public float ActualSampleRate   { get; set; }//Actual Sample Rate:4B
        public byte  Flags              { get; set; }//Flags (to be defined):1B
        
         public new byte[] ReservedByte {//重写基类的ReservedByte属性名字，基类该属性只有一个字节，这里需要三个字节
            get {
                return this._reservedByte;
            }
            set {
                int len = value.Length;
                len = (len > 3) ? 3 : len;
                for (int i = 0; i < len; i++) {
                    this._reservedByte[i] = value[i];
                }
            }
        }
        #region constructors of Block100
        public Block100() { }
        //public Block100(Int16 blockType,Int16 nextBlockByteNum,
        //    byte[] reservedByte, Int32 actualSampleRate, byte flags)
        //    : base(blockType, nextBlockByteNum, reservedByte) {
        //        this.ActualSampleRate = actualSampleRate;
        //        this.Flags            = flags;
        //} //貌似调用基类构造函数麻烦，还不如直接在构造函数直接赋值
        public Block100(Int16 blockType,Int16 nextBlockByteNum,
            byte[] reservedByte, float actualSampleRate, byte flags) {
                this.BlockType          = blockType;
                this.NextBlockByteNum   = nextBlockByteNum;
                this._reservedByte      = reservedByte;
                this.ActualSampleRate   = actualSampleRate;
                this.Flags              = flags;
        }
        #endregion
    } 
    #endregion

    #region Blockette type 200 // Generic Event Detection Blockette (52 bytes)
    /* 一般事件检测分区块[200]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 信号幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  4   | 信号周期           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  5   | 背景估计           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  6   | 事件检测标志       |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  7   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  8   | 信号开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  9   | 检测器名称         |  A    |   24    |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 一般事件检测分区块[200] （52 bytes)
    /// </summary>
    public class Block200 : NBlock {
        private char[] detectorName = new char[24];//Detector Name:24B

        #region The properties of Block200
        public float    SignalAmplitude     { get; set; }// 4B;Signal amplitude
        public float    SignalPeriod        { get; set; }// 4B;Signal period
        public float    BackgroundEstimate  { get; set; }// 4B;Background estimate
        public Byte     EvtDecFlags         { get; set; }// 1B;Event detection flags
        public DateTime SignalOnsetTime     { get; set; }// 10B;Signal onset time
        public string DetectorName {  //Detector Name:24B
            get {
                string _detectorName = new string(detectorName);
                return _detectorName;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (24 < Len) ? 24 : Len;
                for (int i = 0; i < Len; i++)
                    detectorName[i] = str[i];
            }
        }
        #endregion

        #region Constructors of Block200
        public Block200() { }
        public Block200(
            Int16    blockType,
            Int16    nextBlockByteNum,
            byte     reservedByte,
            float    signalAmplitude,   
            float    signalPeriod,     
            float    backgroundEstimate,
            Byte     evtDecFlags,       
            DateTime signalOnsetTime,   
            string   detectorName
            )
            : base(blockType, nextBlockByteNum, reservedByte) {
                this.SignalAmplitude    = signalAmplitude;
                this.SignalPeriod       = signalPeriod;
                this.BackgroundEstimate = backgroundEstimate;
                this.EvtDecFlags        = evtDecFlags;
                this.SignalOnsetTime    = signalOnsetTime;
                this.DetectorName       = detectorName;
        }
        #endregion
    }
    #endregion

    #region Blockette type 201 // Murdock Event Detection Blockette (60 bytes)
    /* Murdock事件检测分区块[201]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 信号幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  4   | 信号周期           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  5   | 背景估计           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  6   | 事件检测标志       |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  7   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  8   | 信号开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  9   | 信噪比             |  B    |   6     |
     * +------|--------------------|-------|---------|
     * |  10  | 回送值             |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  11  | 抽样算法           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  12  | 检测器名称         |  A    |   24    |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Murdock事件检测分区块[201]
    /// </summary>
    public class Block201 : Block200 {
        private byte[] signalToNoiseRatioValues = new byte[6];// 6B;Signal-to-noise ratio values

        #region properties of Block201
        public byte LookbackValue { get; set; }
        public byte PickAlgorithn { get; set; }
        public byte[] SignalToNoiseRatioValues {
            get {
                return this.signalToNoiseRatioValues;
            }
            set {
                int len = value.Length;
                len = (len > 6) ? 6 : len;
                for (int i = 0; i < len; i++) {
                    this.signalToNoiseRatioValues[i] = value[i];
                }
            }
        }
        #endregion

        #region constructors of Block201
        public Block201() { }
        public Block201(
            Int16    blockType,
            Int16    nextBlockByteNum,
            byte     reservedByte,
            float    signalAmplitude,   
            float    signalPeriod,     
            float    backgroundEstimate,
            Byte     evtDecFlags,       
            DateTime signalOnsetTime,   
            string   detectorName,
            byte[]   _signalToNoiseRatioValues,
            byte     lookbackValue,
            byte     pickAlgorithm
            )
            : base(blockType,nextBlockByteNum,reservedByte,signalAmplitude,
            signalPeriod,backgroundEstimate,evtDecFlags,signalOnsetTime,detectorName) {
                this.SignalToNoiseRatioValues = _signalToNoiseRatioValues;
                this.LookbackValue = lookbackValue;
                this.PickAlgorithn = pickAlgorithm;
        }
        #endregion
    }
    #endregion

    #region Blockette type 300 //Step Calibration Blockette (60 bytes)--Class Design
    /* 阶跃标定分区块[300]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 标定开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  4   | 依次阶跃标定数     |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 标定标志           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | 阶跃保持时间       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  7   | 间隔时间           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  8   | 标定信号幅度       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  9   | 标定输入通道       |  A    |   3     |
     * +------|--------------------|-------|---------|
     * |  10  | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  11  | 参考幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  12  | 级联               |  A    |   12    |
     * +------|--------------------|-------|---------|
     * |  13  | 衰减               |  A    |   12    |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 阶跃标定分区块[300]
    /// </summary>
    public class Block300 : Calibration {
        #region Properties of Block300
        public Byte  NumOfStepCalibrations  { get; set; }// 1B;Number of step calibrations
        public float StepDuration           { get; set; }// 4B;Step duration
        public float CalSgnAmplitude        { get; set; }// 4B;Calibration signal amplitude
        #endregion

        #region Constructors of Block300
        public Block300() { }
        public Block300(
            Int16   blockType,
            Int16   nextBlockByteNum,
            byte[]  beginOfCalTime,
            byte    numOfStepCal,
            byte    calibrationFlags,
            float   stepDuration,
            float   intervalDuration,
            float   calSgnAmplitude,
            string  chaWithCalibrationInput,
            byte    reservedByte,
            float   refAmplitude,
            string  coupling,
            string  rolloff
            )
            : base(blockType,nextBlockByteNum,reservedByte,beginOfCalTime,
            calibrationFlags,intervalDuration,chaWithCalibrationInput,refAmplitude,coupling,rolloff) {
                this.NumOfStepCalibrations  = numOfStepCal;
                this.StepDuration           = stepDuration;
                this.CalSgnAmplitude        = calSgnAmplitude;
        }
        #endregion

    }
    #endregion

    #region Blockette type 310 //Sine Calibration Blockette(60 bytes)
    /* 正弦标定分区块[310]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 标定开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  4   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 标定标志           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | 标定保持时间       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  7   | 信号周期           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  8   | 信号幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  9   | 含标定输入通道     |  A    |   3     |
     * +------|--------------------|-------|---------|
     * |  10  | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  11  | 参考幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  12  | 级联               |  A    |   12    |
     * +------|--------------------|-------|---------|
     * |  13  | 衰减               |  A    |   12    |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 正弦标定分区块[310]
    /// </summary>
    public class Block310 : Calibration {
        #region properties of Block310
        public float PeriodOfSignal { get; set; }
        public float AmplitudeOfSgn { get; set; }
        public byte  ReservedByte_2 { get; set; }
        #endregion

        #region constructors of Block310
        public Block310() { }
        public Block310(
            Int16   blockType,
            Int16   nextBlockByteNum,
            byte[]  beginOfCalTime,
            byte    reservedByte,
            byte    calibrationFlags,
            float   calibrationDuration,
            float   periodOfSignal,
            float   amplitudeOfSignal,
            string  chaWithCalibrationInput,
            byte    reservedByte_2,
            float   refAmplitude,
            string  coupling,
            string  rolloff
            )
            : base(blockType, nextBlockByteNum, reservedByte, beginOfCalTime, calibrationFlags,
            calibrationDuration, chaWithCalibrationInput, refAmplitude, coupling, rolloff) {
                this.PeriodOfSignal = periodOfSignal;
                this.AmplitudeOfSgn = amplitudeOfSignal;
                this.ReservedByte_2 = reservedByte_2;
        }
        #endregion
    }
    #endregion

    #region Blockette type 320 // Pseudo-random Calibration Blockette (64 bytes)
    /* 伪随机标定分区块[320]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 标定开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  4   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 标定标志           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | 标定保持时间       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  7   | 阶跃峰峰振幅       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  8   | 含标定输入通道     |  A    |   3     |
     * +------|--------------------|-------|---------|
     * |  9   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  10  | 参考幅度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  11  | 级联               |  A    |   12    |
     * +------|--------------------|-------|---------|
     * |  12  | 衰减               |  A    |   12    |
     * +------|--------------------|-------|---------|
     * |  13  | 噪音类型           |  A    |   8     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 伪随机标定分区块[320]
    /// </summary>
    public class Block320 : Calibration {
        private char[] noiseType = new char[8];  //Noise Type:8B

        #region properties of block320
        public float P2PAmplitudeOfSteps { get; set; }//FLOAT: Peak-to-peak amplitude of steps in units (see Channel Identifier Blockette [52], field 9).
        public byte  ReservedByte_2      { get; set; }
        public string NoiseType { //Noise Type:8B
            get {
                string _noiseType = new string(noiseType);
                return _noiseType;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (8 < Len) ? 8 : Len;
                for (int i = 0; i < Len; i++)
                    noiseType[i] = str[i];
            }
        }
        #endregion

        #region constructors of Block320
        public Block320() { }
        public Block320(
            Int16   blockType,
            Int16   nextBlockByteNum,
            byte[]  beginOfCalTime,
            byte    reservedByte,
            byte    calibrationFlags,
            float   calibrationDuration,
            float   p2pAmplitudeOfSteps,
            string  chaWithCalibrationInput,
            byte    reservedByte_2,
            float   refAmplitude,
            string  coupling,
            string  rolloff,
            string  noiseType
            )
            : base(blockType,nextBlockByteNum,reservedByte,beginOfCalTime,calibrationFlags,
            calibrationDuration, chaWithCalibrationInput, refAmplitude, coupling, rolloff ) {
                this.P2PAmplitudeOfSteps = p2pAmplitudeOfSteps;
                this.ReservedByte_2      = reservedByte_2;
                this.NoiseType           = noiseType;
        }
        #endregion
    }
    #endregion

    #region Blockette type 390 //Generic Calibration Blockette (28 bytes)
    /* 一般标定分区块[390]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 标定开始时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  4   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 标定标志           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | 标定保持时间       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  7   | 标定信号幅度       |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  8   | 含标定输入通道     |  A    |   3     |
     * +------|--------------------|-------|---------|
     * |  9   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 一般标定分区块[390]
    /// </summary>
    public class Block390 : NBlock {
        #region fields of Block390
        private byte[] beginOfCalibrationTime  = new byte[10];// 10B;Beginning of calibration time
        private char[] chaWithCalibrationInput = new char[3]; // 3B;Channel with calibration input
        #endregion

        #region properties of Block390
        public Byte  CalibrationFlags   { get; set; }//Calibration flags:1B
        public float CalibrationDuration{ get; set; }//Interval duration:4B
        public byte  ReservedByte_2     { get; set; }
        public float CalSgnAmplitude    { get; set; }//Calibration signal amplitude:4B
        public byte[] BeginOfCalibrationTime {
            get {
                return this.beginOfCalibrationTime;
            }
            set {
                int len = value.Length;
                len = (len > 10) ? 10 : len;
                for (int i = 0; i < len; i++) {
                    this.beginOfCalibrationTime[i] = value[i];
                }
            }
        }
        public string ChaWithCalibrationInput { //Channel with calibration input:3B
            get {
                string _calInputChannel = new string(chaWithCalibrationInput);
                return _calInputChannel;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (3 < Len) ? 3 : Len;
                for (int i = 0; i < Len; i++)
                    chaWithCalibrationInput[i] = str[i];
            }
        }
        #endregion

        #region constructors of Block390
        public Block390() { }
        public Block390(
            Int16   blockType,
            Int16   nextBlockByteNum,
            byte    reservedByte,
            byte[]  begOfCalibrationTime,
            byte    calibrationFlags,
            float   calibrationDuration,
            float   calibrationSgnAmplitude,
            string  chaWithCalibrationInput,
            byte    reservedBtye_2
            )
            : base(blockType, nextBlockByteNum, reservedByte) {
                this.BeginOfCalibrationTime = beginOfCalibrationTime;
                this.CalibrationFlags       = calibrationFlags;
                this.CalibrationDuration    = calibrationDuration;
                this.CalSgnAmplitude        = calibrationSgnAmplitude;
                this.ChaWithCalibrationInput = chaWithCalibrationInput;
                this.ReservedByte_2         = reservedBtye_2;
        }
        #endregion
    }
    #endregion

    #region Blockette type 395 //Calibration Abort Blockette (16 bytes)
    /* 标定失败(中断)分区块[395]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 标定结束时间       |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  4   | 保留字节           |  B    |   1     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// 标定失败(中断)分区块[395]
    /// </summary>
    public class Block395 : NBlock {
        #region properties of Block395
        public DateTime EndOfCalTime    { get; set; }//End of calibration time:10B
        public new UInt16 ReservedByte  { get; set; }//Reserved bytes:2B
        #endregion

        #region constructors of Block395
        public Block395() { }
        public Block395(Int16 blockType,Int16 nextBlockByteNum,byte reservedByte,DateTime endOfCalTime) {
            this.BlockType          = blockType;
            this.NextBlockByteNum   = nextBlockByteNum;
            this.ReservedByte       = reservedByte;
            this.EndOfCalTime       = endOfCalTime;
        }
        #endregion

    }
    #endregion

    #region Blockette type 400 // Beam Blockette (16 bytes)--Class Design
    /* Beam分区块[400]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | Beam主位角(度)     |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  4   | Beam慢度           |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  5   | Beam构成           |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  6   | 保留字节           |  B    |   2     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Beam分区块[400]
    /// 本分区块用来说明Beam结构分区块[035]所描述的Bean是如何构成的
    /// </summary>
    public class Block400 {
        #region The properties of Beam Blockette
        public UInt16   BlockType           { get; set; }//Blockette type — 400:2B
        public UInt16   NextBlockByteNum    { get; set; }//Next blockette’s byte number:2B
        public float    BeamAzimuth         { get; set; }//Beam azimuth (degrees):4B
        public float    BeamSlowness        { get; set; }//Beam slowness (sec/degree):4B
        public UInt16   BeamConfiguration   { get; set; }//Beam configuration:2B
        public UInt16   ReservedBytes       { get; set; }//Reserved bytes:2B
        #endregion

        #region constructors of Block400
        public Block400() { }
        public Block400(UInt16 blockType,UInt16 nextBlocByteNum,
            float beamAzimuth,float beamSlowness,UInt16 beamConfiguraion,UInt16 reservedBytes) {
                this.BlockType          = blockType;
                this.NextBlockByteNum   = nextBlocByteNum;
                this.BeamAzimuth        = beamAzimuth;
                this.BeamSlowness       = beamSlowness;
                this.BeamConfiguration  = beamConfiguraion;
                this.ReservedBytes      = reservedBytes;
        }
        #endregion
    }
    #endregion

    #region Blockette type 405 //Beam Delay Blockette (6 bytes)
    /* Beam延时分区块[405]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   |Array of delay Values  B    |   4     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Beam延时分区块[405]
    /// 本分区块总是跟在Beam分区块[400]之后，它定义
    /// 的Beam不象平面波那样在台阵中匀速传播，对千非平面
    /// 波形成的Beam，分区块[035]涉及的每一个分量成员，
    /// 车分区块都说明其延时。SEED读程序必须找到分区块
    /// [035]所给出的台阵Beam 响应入口，而这个入口是由
    /// Beam分区块[400]索引的
    /// </summary>
    public class Block405 {
        #region The properties of Beam Delay Blockette
        public UInt16 BlockType             { get; set; }//Blockette type — 405:2B
        public UInt16 NextBlockByteNum      { get; set; }//Next blockette’s byte number:2B
        public UInt16 ArrayOfDelayValues    { get; set; }//Array of delay values:2B
        #endregion
        #region constructors of Block405
        public Block405() { }
        public Block405(UInt16 blockType,UInt16 nextBlockByteNum,UInt16 arrayOfDelayValues) {
            this.BlockType          = blockType;
            this.NextBlockByteNum   = nextBlockByteNum;
            this.ArrayOfDelayValues = arrayOfDelayValues;
        }
        #endregion
    }
    #endregion

    #region Blockette type 500 // Timing Blockette (200 bytes)
    /* Timing分区块[500]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |Next Blockette offset  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | VCO correction     |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  4   | Time off exception |  B    |   10    |
     * +------|--------------------|-------|---------|
     * |  5   | usec               |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | Reception Quality  |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  7   | Exception count    |  B    |   4     |
     * +------|--------------------|-------|---------|
     * |  8   | Exception type     |  A    |   16    |
     * +------|--------------------|-------|---------|
     * |  9   | Clock model        |  A    |   32    |
     * +------|--------------------|-------|---------|
     * |  10  | Clock status       |  A    |   128   |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Timing分区块[500]
    /// </summary>
    public class Block500 {

        #region The fields of Timing Blockette
        private char[] exceptionType    = new char[16]; //Exception type:16B
        private char[] clockModel       = new char[32]; //Clock model:32B
        private char[] clockStatus      = new char[128];//Clock status:128B
        #endregion

        #region The properties of Timing Blockette
        public UInt16   BlocketteType       { get; set; }//Blockette type — 500:2B
        public UInt16   NextBlockOffset     { get; set; }//Next blockette offset:2B
        public float    VCOCorrection       { get; set; }//VCO correction:4B
        public DateTime TimeOfException     { get; set; }//Time of exception:10B
        public SByte    usec                { get; set; }//μsec:1B
        public Byte     ReceptionQuality    { get; set; }//Reception Quality:1B
        public ulong    ExceptionCount      { get; set; }//Exception count:4B
        public string ExceptionType { //Exception type:16B
            get {
                string _exceptionType = new string(exceptionType);
                return _exceptionType;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (16 < Len) ? 16 : Len;
                for (int i = 0; i < Len; i++)
                    exceptionType[i] = str[i];
            }
        }
        public string ClockModel { //Clock model:32B
            get {
                string _clockModel = new string(clockModel);
                return _clockModel;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (32 < Len) ? 32 : Len;
                 for (int i = 0; i < Len; i++)
                    clockModel[i] = str[i];
            }
        }
        public string ClockStatus { //Clock status:128B
            get {
                string _clockStatus = new string(clockStatus);
                return _clockStatus;
            }
            set {
                int Len = value.Length;
                char[] str = new char[Len];
                str = value.ToCharArray();
                Len = (128 < Len) ? 128 : Len;
                for (int i = 0; i < Len; i++)
                    clockStatus[i] = str[i];
            }
        }
        #endregion
        #region constructors of Block500
        public Block500() { }
        public Block500(UInt16 blockType, UInt16 nextBlockOffset, float vcoCorrection,
            DateTime timeOfException, sbyte usec, byte receptionQuality, ulong exceptionCount,
            string exceptionType, string clockModel, string clockStatus) { 
                this.BlocketteType      = blockType;
                this.NextBlockOffset    = nextBlockOffset;
                this.VCOCorrection      = vcoCorrection;
                this.TimeOfException    = timeOfException;
                this.usec               = usec;
                this.ReceptionQuality   = receptionQuality;
                this.ExceptionCount     = exceptionCount;
                this.ExceptionType      = exceptionType;
                this.ClockModel         = clockModel;
                this.ClockStatus        = clockStatus;
        }
        #endregion
    }
    #endregion

    #region Blockette type 1000 // Data Only SEED Blockette (8 bytes)
    /* Data Only SEED分区块[1000]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | 编码格式           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  4   | 字命令             |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | 数据记录长度       |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | 保留字节           |  B    |   2     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Data Only SEED分区块[1000]
    /// 由于数据记录本身不包括允许绘御和简单分析时间
    /// 序列的足够信息，车分区块在定义时间序列方面增设了
    /// 少量的辅助信息，从而排除了上述限制
    /// </summary>
    public class Block1000 {
        #region The properties of Data Only SEED Blockette
        public UInt16   BlocketteType   { get; set; }//Blockette type — 1000:2B
        public UInt16   NextBlockSize   { get; set; }//Next blockette’s byte number:2B
        public Byte     EcodingFormat   { get; set; }//Encoding Format:1B
        public Byte     WordOrder       { get; set; }//Word order:1B
        public Byte     LengthOfDataRec { get; set; }//Data Record Length:1B
        public Byte     Reserved        { get; set; }//Reserved:1B
        #endregion

        #region contructors of Block1000
        public Block1000() { }
        public Block1000(
            UInt16   blocketteType,  
            UInt16   nextBlockSize,  
            Byte     ecodingFormat,  
            Byte     wordOrder,      
            Byte     lengthOfDataRec,
            Byte     reserved
            ) {
                this.BlocketteType  = blocketteType;
                this.NextBlockSize  = nextBlockSize;
                this.EcodingFormat  = ecodingFormat;
                this.WordOrder      = wordOrder;
                this.LengthOfDataRec = lengthOfDataRec;
                this.Reserved       = reserved;
        }
        #endregion
    }
    #endregion

    #region Blockette type 1001 // Data Extension Blockette (8 bytes)--Class Design
    /* Data Extension分区块[1001]的结构
     * +------|--------------------|-------|---------| 
     * |字段号|     字段名         |  类型 |  长度   | 
     * +------|--------------------|-------|---------| 
     * |  1   | 分区块类型         |  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  2   |下个分区块的字节编号|  B    |   2     |
     * +------|--------------------|-------|---------|
     * |  3   | Timing quality     |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  4   | usec               |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  5   | Reserved           |  B    |   1     |
     * +------|--------------------|-------|---------|
     * |  6   | Frame count        |  B    |   1     |
     * +------|--------------------|-------|---------|
     */
    /// <summary>
    /// Data Extension分区块[1001]
    /// </summary>
    public class Block1001 {
        #region The properties of Data Extension Blockette
        public UInt16   BlocketteType   { get; set; }//Blockette type — 1001:2B
        public UInt16   NextBlockByteNum{ get; set; }//Next blockette’s byte number:2B
        public Byte     TimmingQuality  { get; set; }//Timing quality:1B
        public Byte     usec            { get; set; }//μsec:1B
        public Byte     Reserved        { get; set; }//Reserved:1B
        public Byte     FrameCount      { get; set; }//Frame count:1B
        #endregion

        #region constructors of Block1001
        public Block1001() { }
        public Block1001(
            UInt16   blocketteType, 
            UInt16   nextBlockByteNum, 
            Byte     timmingQuality,
            Byte     _usec,          
            Byte     reserved,      
            Byte     frameCount
            ) {
                this.BlocketteType      = blocketteType;
                this.NextBlockByteNum   = nextBlockByteNum;
                this.TimmingQuality     = timmingQuality;
                this.usec       = _usec;
                this.Reserved   = reserved;
                this.FrameCount = frameCount;
        }
        #endregion
    }
    #endregion

    #region Blockette type 2000 // Variable Length Opaque Data Blockette
    /* Variable Length Opaque Data 分区块[2000]的结构
     * +------|-----------------------|-------|---------|---------| 
     * |字段号|     字段名            |  类型 |  长度   |  Offset | 
     * +------|-----------------------|-------|---------|---------| 
     * |  1   | 分区块类型            |  B    |   2     |  0      |
     * +------|-----------------------|-------|---------|---------|
     * |  2   |下个分区块的字节编号   |  B    |   2     |  2      |
     * +------|-----------------------|-------|---------|---------|
     * |  3   | 字节总长度            |  B    |   2     |  4      |
     * +------|-----------------------|-------|---------|---------|
     * |  4   |Offset of Opaque Data  |   B    |   2     |  6      |
     * +------|-----------------------|-------|---------|---------|
     * |  5   | 记录号                |  B    |   4     |  10     |
     * +------|-----------------------|-------|---------|---------|
     * |  6   | Data Word order       |  B    |   1     |  12     |
     * +------|-----------------------|-------|---------|---------|
     * |  7   | Opaque Data flags     |  B    |   1     |  13     |
     * +------|-----------------------|-------|---------|---------|
     * |  8   |Num of Opaque HF       |  B    |   1     |  14     |//Number of Opaque Header fields
     * +------|-----------------------|-------|---------|---------|
     * |  9   |Opaque Data HF         |  V    |   V     |  15     |//Opaque Data Header fields
     * +------|-----------------------|-------|---------|---------|
     * |  10  |Opaque Data            |Opaque |         |         |
     * +------|-----------------------|-------|---------|---------+
     */
    /// <summary>
    /// Variable Length Opaque Data 分区块[2000]
    /// </summary>
    public class Block2000 {
        #region The fields of Variable Length Opaque Data Blockette
        private struct opaqueDataHead {

        }
        #endregion
        #region The properties of Variable Length Opaque Data Blockette
        public UInt16   BlocketteType       { get; set; }//Blockette type — 2000:2B
        public UInt16   NextBlockSize       { get; set; }//Next blockette’s byte number:2B
        public UInt16   TotalBlockLength    { get; set; }//Total blockette length in bytes:2B
        public UInt16   OffsetToOpaqueData  { get; set; }//Offset to Opaque Data:2B
        public ulong    RecordType          { get; set; }//Record number:4B
        public Byte     DataWordOrder       { get; set; }//Data Word order:1B
        public Byte     OpaqueDataFlags     { get; set; }//Opaque Data flags:1B
        public Byte     OpaqueHeadFieldsNum { get; set; }//Number of Opaque Header fields:1B
        #endregion

        #region constructors of Block2000
        public Block2000() { }
        #endregion
    }
    #endregion
}
